path: root/display-presets.patch

From 924cdf31df01beab871596b9fc82282f2a17953a Mon Sep 17 00:00:00 2001
From: Jerzy Kolosowski <jerzy@kolosowscy.pl>
Date: Tue, 16 Sep 2025 19:52:41 +0200
Subject: [PATCH] Add Display Presets feature to KScreen
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This comprehensive feature adds display preset functionality to KScreen,
allowing users to save, manage, and quickly switch between different
display configurations. The implementation includes:

- Complete preset management system with save/load/delete operations
- Integration across KCM, KDED daemon, and Plasma applet
- Real-time preview functionality showing preset configurations
- Keyboard shortcuts support for quick preset switching
- File monitoring for automatic preset synchronization
- Architecture supporting monitor availability detection
- Enhanced UI with current status detection and improved layouts

The feature is implemented with a clean separation of concerns:
- Common library for shared preset utilities
- KDED daemon integration for system-wide preset management
- KCM interface for comprehensive preset configuration
- Plasma applet for quick access and switching

FEATURE: Display Presets for KScreen
CHANGELOG: Add display preset functionality with save/load/preview capabilities
Signed-off-by: Jerzy Kołosowski <jerzy@kolosowscy.pl>
---
 CMakeLists.txt                         |   2 +
 common/CMakeLists.txt                  |   3 +-
 common/presets.cpp                     | 498 ++++++++++++++++++++++++
 common/presets.h                       | 107 ++++++
 kcm/CMakeLists.txt                     |   1 +
 kcm/kcm.cpp                            | 230 +++++++++++
 kcm/kcm.h                              |  24 ++
 kcm/preset_manager.cpp                 | 229 +++++++++++
 kcm/preset_manager.h                   |  57 +++
 kcm/ui/PresetOutput.qml                | 198 ++++++++++
 kcm/ui/PresetPage.qml                  | 356 +++++++++++++++++
 kcm/ui/PresetView.qml                  |  95 +++++
 kcm/ui/ScreenView.qml                  |   7 +
 kcm/ui/main.qml                        |  19 +-
 kded/CMakeLists.txt                    |   1 +
 plasmoid/CMakeLists.txt                |  13 +
 plasmoid/PresetList.qml                | 239 ++++++++++++
 plasmoid/PresetOutput.qml              | 179 +++++++++
 plasmoid/PresetView.qml                |  96 +++++
 plasmoid/kscreenapplet.cpp             | 237 ++++++++++++
 plasmoid/kscreenapplet.h               |  47 +++
 plasmoid/main.qml                      |  10 +
 presets/CMakeLists.txt                 |  38 ++
 presets/main.cpp                       |  57 +++
 presets/org.kde.kscreen.presets.xml    |  19 +
 presets/plasma-kscreen-presets.service |   8 +
 presets/presetsservice.cpp             | 461 ++++++++++++++++++++++
 presets/presetsservice.h               |  62 +++
 tests/CMakeLists.txt                   |   1 +
 tests/presets/CMakeLists.txt           |  28 ++
 tests/presets/testpresets.cpp          | 507 +++++++++++++++++++++++++
 tests/presets/testsimple.cpp           | 121 ++++++
 32 files changed, 3943 insertions(+), 7 deletions(-)
 create mode 100644 common/presets.cpp
 create mode 100644 common/presets.h
 create mode 100644 kcm/preset_manager.cpp
 create mode 100644 kcm/preset_manager.h
 create mode 100644 kcm/ui/PresetOutput.qml
 create mode 100644 kcm/ui/PresetPage.qml
 create mode 100644 kcm/ui/PresetView.qml
 create mode 100644 plasmoid/PresetList.qml
 create mode 100644 plasmoid/PresetOutput.qml
 create mode 100644 plasmoid/PresetView.qml
 create mode 100644 presets/CMakeLists.txt
 create mode 100644 presets/main.cpp
 create mode 100644 presets/org.kde.kscreen.presets.xml
 create mode 100644 presets/plasma-kscreen-presets.service
 create mode 100644 presets/presetsservice.cpp
 create mode 100644 presets/presetsservice.h
 create mode 100644 tests/presets/CMakeLists.txt
 create mode 100644 tests/presets/testpresets.cpp
 create mode 100644 tests/presets/testsimple.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ccc882f0..29c3aa4f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,6 +38,7 @@ find_package(Qt6 ${QT_MIN_VERSION} REQUIRED COMPONENTS Gui Test Sensors QuickCon
 find_package(KF6 ${KF6_MIN_VERSION} REQUIRED COMPONENTS
     Config
     DBusAddons
+    GlobalAccel
     I18n
     KCMUtils
     Svg
@@ -92,6 +93,7 @@ add_subdirectory(common)
 add_subdirectory(kcm)
 add_subdirectory(kded)
 add_subdirectory(osd)
+add_subdirectory(presets)
 add_subdirectory(plasmoid)
 add_subdirectory(tests)
 add_subdirectory(console)
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index f7341866..1c61817f 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -1,5 +1,6 @@
-add_library(kscreen_common OBJECT control.cpp globals.cpp orientation_sensor.cpp osdaction.cpp output.cpp utils.cpp)
+add_library(kscreen_common OBJECT control.cpp globals.cpp orientation_sensor.cpp osdaction.cpp output.cpp utils.cpp presets.cpp)
 ecm_qt_declare_logging_category(kscreen_common HEADER kscreen_daemon_debug.h IDENTIFIER KSCREEN_KDED CATEGORY_NAME kscreen.kded DESCRIPTION "kscreen kded (kscreen)" EXPORT KSCREEN)
+ecm_qt_declare_logging_category(kscreen_common HEADER kscreen_common_debug.h IDENTIFIER KSCREEN_COMMON CATEGORY_NAME kscreen.common DESCRIPTION "kscreen common library (kscreen)" EXPORT KSCREEN)
 set_property(TARGET kscreen_common PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(kscreen_common PRIVATE Qt::Core Qt::Sensors KF6::Screen KF6::CoreAddons KF6::I18n)
 target_include_directories(kscreen_common PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>")
diff --git a/common/presets.cpp b/common/presets.cpp
new file mode 100644
index 00000000..03958fec
--- /dev/null
+++ b/common/presets.cpp
@@ -0,0 +1,498 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#include "presets.h"
+#include "kscreen_common_debug.h"
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QStandardPaths>
+
+Presets::Presets(QObject *parent, const QString &customFilePath)
+    : QAbstractListModel(parent)
+    , m_fileWatcher(new QFileSystemWatcher(this))
+    , m_customPresetsFilePath(customFilePath)
+{
+    loadPresetsFromDisk();
+
+    const QString filePath = presetsFilePath();
+    if (QFile::exists(filePath)) {
+        m_fileWatcher->addPath(filePath);
+    }
+    connect(m_fileWatcher, &QFileSystemWatcher::fileChanged, this, &Presets::onPresetFileChanged);
+}
+
+int Presets::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+    return m_presets.count();
+}
+
+QVariant Presets::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_presets.count()) {
+        return QVariant();
+    }
+
+    const DisplayPreset &preset = m_presets.at(index.row());
+
+    switch (role) {
+    case IdRole:
+        return preset.id;
+    case NameRole:
+        return preset.name;
+    case DescriptionRole:
+        return preset.description;
+    case CreatedRole:
+        return preset.created;
+    case LastUsedRole:
+        return preset.lastUsed;
+    case OutputCountRole:
+        return preset.outputIds.count();
+    case ConfigurationRole:
+        return preset.configuration;
+    case ShortcutRole:
+        return preset.shortcut;
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> Presets::roleNames() const
+{
+    return {
+        {IdRole, "presetId"},
+        {NameRole, "name"},
+        {DescriptionRole, "description"},
+        {CreatedRole, "created"},
+        {LastUsedRole, "lastUsed"},
+        {OutputCountRole, "outputCount"},
+        {ConfigurationRole, "configuration"},
+        {ShortcutRole, "shortcut"},
+    };
+}
+
+bool Presets::hasPresets() const
+{
+    return !m_presets.isEmpty();
+}
+
+KScreen::ConfigPtr Presets::screenConfiguration() const
+{
+    return m_screenConfiguration;
+}
+
+void Presets::setScreenConfiguration(KScreen::ConfigPtr config)
+{
+    m_screenConfiguration = config;
+    Q_EMIT screenConfigurationChanged();
+}
+
+bool Presets::isPresetAvailable(const QString &presetId) const
+{
+    if (!m_screenConfiguration) {
+        qCDebug(KSCREEN_COMMON) << "No screen configuration available for preset" << presetId;
+        return false;
+    }
+
+    const auto preset = getPreset(presetId);
+    if (preset.id.isEmpty()) {
+        qCDebug(KSCREEN_COMMON) << "Preset not found:" << presetId;
+        return false;
+    }
+
+    // Check if all required outputs are currently connected
+    const auto presetOutputsList = preset.configuration[QStringLiteral("outputs")].toList();
+    const auto currentOutputs = m_screenConfiguration->outputs();
+
+    for (const auto &presetOutputVariant : presetOutputsList) {
+        const auto presetOutputMap = presetOutputVariant.toMap();
+        const QString presetOutputName = presetOutputMap[QStringLiteral("name")].toString();
+
+        // Only check outputs that are supposed to be enabled in the preset
+        if (!presetOutputMap[QStringLiteral("enabled")].toBool()) {
+            continue;
+        }
+
+        bool found = false;
+        for (const auto &currentOutput : currentOutputs) {
+            if (currentOutput->name() == presetOutputName && currentOutput->isConnected()) {
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) {
+            qCDebug(KSCREEN_COMMON) << "Output not found or not connected:" << presetOutputName << "for preset" << presetId;
+            return false;
+        }
+    }
+
+    qCDebug(KSCREEN_COMMON) << "Preset available:" << presetId;
+    return true;
+}
+
+bool Presets::isPresetCurrent(const QString &presetId) const
+{
+    if (!m_screenConfiguration) {
+        return false;
+    }
+
+    const auto preset = getPreset(presetId);
+    if (preset.id.isEmpty()) {
+        return false;
+    }
+
+    const auto presetOutputsList = preset.configuration[QStringLiteral("outputs")].toList();
+    const auto currentOutputs = m_screenConfiguration->outputs();
+
+    // Check each currently connected output
+    for (const auto &currentOutput : currentOutputs) {
+        if (!currentOutput->isConnected()) {
+            continue;
+        }
+
+        bool found = false;
+        for (const auto &presetOutputVariant : presetOutputsList) {
+            const auto presetOutputMap = presetOutputVariant.toMap();
+            if (presetOutputMap[QStringLiteral("name")].toString() == currentOutput->name()) {
+                found = true;
+
+                // Check if enabled state matches
+                if (currentOutput->isEnabled() != presetOutputMap[QStringLiteral("enabled")].toBool()) {
+                    return false;
+                }
+
+                // If output is enabled, check other properties
+                if (currentOutput->isEnabled()) {
+                    // Check priority
+                    if (static_cast<uint32_t>(presetOutputMap[QStringLiteral("priority")].toInt()) != currentOutput->priority()) {
+                        return false;
+                    }
+
+                    // Check position
+                    const auto presetPos = presetOutputMap[QStringLiteral("pos")].toMap();
+                    const QPoint presetPosition(presetPos[QStringLiteral("x")].toInt(), presetPos[QStringLiteral("y")].toInt());
+                    if (currentOutput->pos() != presetPosition) {
+                        return false;
+                    }
+
+                    // Check mode (resolution)
+                    const auto presetMode = presetOutputMap[QStringLiteral("mode")].toMap();
+                    if (currentOutput->currentModeId() != presetMode[QStringLiteral("id")].toString()) {
+                        return false;
+                    }
+
+                    // Check scale
+                    if (qAbs(currentOutput->scale() - presetOutputMap[QStringLiteral("scale")].toReal()) > 0.01) {
+                        return false;
+                    }
+
+                    // Check rotation
+                    if (static_cast<int>(currentOutput->rotation()) != presetOutputMap[QStringLiteral("rotation")].toInt()) {
+                        return false;
+                    }
+                }
+                break;
+            }
+        }
+
+        // If current output is enabled but not found in preset, it's not current
+        if (!found && currentOutput->isEnabled()) {
+            return false;
+        }
+    }
+
+    // Also check that preset doesn't expect outputs that aren't currently available
+    for (const auto &presetOutputVariant : presetOutputsList) {
+        const auto presetOutputMap = presetOutputVariant.toMap();
+        if (presetOutputMap[QStringLiteral("enabled")].toBool()) {
+            const QString presetOutputName = presetOutputMap[QStringLiteral("name")].toString();
+
+            bool found = false;
+            for (const auto &currentOutput : currentOutputs) {
+                if (currentOutput->name() == presetOutputName && currentOutput->isConnected() && currentOutput->isEnabled()) {
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+void Presets::refreshPresetStatus()
+{
+    Q_EMIT presetsChanged();
+    Q_EMIT dataChanged(index(0), index(rowCount() - 1));
+}
+
+DisplayPreset Presets::getPreset(const QString &presetId) const
+{
+    auto it = std::ranges::find_if(m_presets, [&presetId](const DisplayPreset &preset) {
+        return preset.id == presetId;
+    });
+
+    if (it != m_presets.end()) {
+        return *it;
+    }
+
+    return DisplayPreset{};
+}
+
+bool Presets::presetExists(const QString &name) const
+{
+    return std::any_of(m_presets.begin(), m_presets.end(), [&name](const DisplayPreset &preset) {
+        return preset.name == name;
+    });
+}
+
+void Presets::updateLastUsed(const QString &presetId)
+{
+    auto it = std::find_if(m_presets.begin(), m_presets.end(), [&presetId](const DisplayPreset &preset) {
+        return preset.id == presetId;
+    });
+
+    if (it != m_presets.end()) {
+        it->lastUsed = QDateTime::currentDateTime();
+        savePresetsToDisk();
+    }
+}
+
+void Presets::loadPresetsFromDisk()
+{
+    const QString filePath = presetsFilePath();
+    QFile file(filePath);
+
+    if (!file.exists()) {
+        return;
+    }
+
+    if (!file.open(QIODevice::ReadOnly)) {
+        const QString error = QStringLiteral("Could not open presets file for reading: %1").arg(filePath);
+        qCWarning(KSCREEN_COMMON) << error;
+        Q_EMIT loadingFailed(error);
+        return;
+    }
+
+    QJsonParseError parseError;
+    const QJsonDocument doc = QJsonDocument::fromJson(file.readAll(), &parseError);
+    if (parseError.error != QJsonParseError::NoError) {
+        const QString error = QStringLiteral("Error parsing presets file: %1").arg(parseError.errorString());
+        qCWarning(KSCREEN_COMMON) << error;
+        Q_EMIT loadingFailed(error);
+        return;
+    }
+
+    const QJsonObject root = doc.object();
+    const QJsonArray presetsArray = root[QStringLiteral("presets")].toArray();
+
+    beginResetModel();
+    m_presets.clear();
+
+    for (const QJsonValue &value : presetsArray) {
+        const QJsonObject presetObj = value.toObject();
+        DisplayPreset preset;
+        preset.id = presetObj[QStringLiteral("id")].toString();
+        preset.name = presetObj[QStringLiteral("name")].toString();
+        preset.description = presetObj[QStringLiteral("description")].toString();
+        preset.created = QDateTime::fromString(presetObj[QStringLiteral("created")].toString(), Qt::ISODate);
+        preset.lastUsed = QDateTime::fromString(presetObj[QStringLiteral("lastUsed")].toString(), Qt::ISODate);
+        preset.configuration = presetObj[QStringLiteral("configuration")].toObject().toVariantMap();
+        preset.shortcut = QKeySequence(presetObj[QStringLiteral("shortcut")].toString());
+
+        // Extract output IDs
+        const QJsonArray outputIds = presetObj[QStringLiteral("outputIds")].toArray();
+        for (const QJsonValue &outputId : outputIds) {
+            preset.outputIds.append(outputId.toString());
+        }
+
+        m_presets.append(preset);
+    }
+
+    endResetModel();
+    Q_EMIT presetsChanged();
+}
+
+void Presets::savePresetsToDisk()
+{
+    const QString filePath = presetsFilePath();
+    QFile file(filePath);
+
+    // Create directory if it doesn't exist
+    QDir dir = QFileInfo(filePath).absoluteDir();
+    if (!dir.exists()) {
+        dir.mkpath(QStringLiteral("."));
+    }
+
+    if (!file.open(QIODevice::WriteOnly)) {
+        const QString error = QStringLiteral("Could not open presets file for writing: %1").arg(filePath);
+        qCWarning(KSCREEN_COMMON) << error;
+        Q_EMIT savingFailed(error);
+        return;
+    }
+
+    QJsonArray presetsArray;
+    for (const DisplayPreset &preset : m_presets) {
+        QJsonObject presetObj;
+        presetObj[QStringLiteral("id")] = preset.id;
+        presetObj[QStringLiteral("name")] = preset.name;
+        presetObj[QStringLiteral("description")] = preset.description;
+        presetObj[QStringLiteral("created")] = preset.created.toString(Qt::ISODate);
+        presetObj[QStringLiteral("lastUsed")] = preset.lastUsed.toString(Qt::ISODate);
+        presetObj[QStringLiteral("configuration")] = QJsonObject::fromVariantMap(preset.configuration);
+        presetObj[QStringLiteral("shortcut")] = preset.shortcut.toString();
+
+        QJsonArray outputIds;
+        for (const QString &outputId : preset.outputIds) {
+            outputIds.append(outputId);
+        }
+        presetObj[QStringLiteral("outputIds")] = outputIds;
+
+        presetsArray.append(presetObj);
+    }
+
+    QJsonObject root;
+    root[QStringLiteral("version")] = 1;
+    root[QStringLiteral("presets")] = presetsArray;
+
+    QJsonDocument doc(root);
+    file.write(doc.toJson());
+
+    // Ensure the file is watched after creation/modification
+    if (!m_fileWatcher->files().contains(filePath)) {
+        m_fileWatcher->addPath(filePath);
+    }
+}
+
+QString Presets::presetsFilePath() const
+{
+    if (!m_customPresetsFilePath.isEmpty()) {
+        return m_customPresetsFilePath;
+    }
+
+    const QString dataDir = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
+    return dataDir + QStringLiteral("/kscreen/presets.json");
+}
+
+void Presets::setCustomPresetsFilePath(const QString &filePath)
+{
+    m_customPresetsFilePath = filePath;
+}
+
+void Presets::reloadPresets()
+{
+    // Remove old file watcher if exists
+    if (!m_fileWatcher->files().isEmpty()) {
+        m_fileWatcher->removePaths(m_fileWatcher->files());
+    }
+
+    // Clear existing presets
+    beginResetModel();
+    m_presets.clear();
+    endResetModel();
+
+    // Load presets from the new path
+    loadPresetsFromDisk();
+
+    // Add new file to watcher
+    const QString filePath = presetsFilePath();
+    if (QFile::exists(filePath)) {
+        m_fileWatcher->addPath(filePath);
+    }
+
+    Q_EMIT presetsChanged();
+}
+
+void Presets::onPresetFileChanged()
+{
+    const QString filePath = presetsFilePath();
+    if (!QFile::exists(filePath)) {
+        // File was deleted, clear presets
+        beginResetModel();
+        m_presets.clear();
+        endResetModel();
+        Q_EMIT presetsChanged();
+        return;
+    }
+
+    // Re-add the file to watcher since Qt removes it after modification
+    if (!m_fileWatcher->files().contains(filePath)) {
+        m_fileWatcher->addPath(filePath);
+    }
+
+    // Reload presets from disk
+    loadPresetsFromDisk();
+    Q_EMIT presetsChanged();
+}
+
+void Presets::addPreset(const DisplayPreset &preset)
+{
+    beginInsertRows(QModelIndex(), m_presets.count(), m_presets.count());
+    m_presets.append(preset);
+    endInsertRows();
+    Q_EMIT presetsChanged();
+}
+
+void Presets::updatePreset(const QString &presetId, const DisplayPreset &preset)
+{
+    auto it = std::find_if(m_presets.begin(), m_presets.end(), [&presetId](const DisplayPreset &p) {
+        return p.id == presetId;
+    });
+
+    if (it != m_presets.end()) {
+        const int row = std::distance(m_presets.begin(), it);
+        m_presets[row] = preset;
+        Q_EMIT dataChanged(index(row), index(row));
+        Q_EMIT presetsChanged();
+    }
+}
+
+void Presets::removePreset(const QString &presetId)
+{
+    auto it = std::find_if(m_presets.begin(), m_presets.end(), [&presetId](const DisplayPreset &preset) {
+        return preset.id == presetId;
+    });
+
+    if (it != m_presets.end()) {
+        const int row = std::distance(m_presets.begin(), it);
+        beginRemoveRows(QModelIndex(), row, row);
+        m_presets.erase(it);
+        endRemoveRows();
+        Q_EMIT presetsChanged();
+    }
+}
+
+DisplayPreset *Presets::findPreset(const QString &presetId)
+{
+    auto it = std::find_if(m_presets.begin(), m_presets.end(), [&presetId](const DisplayPreset &preset) {
+        return preset.id == presetId;
+    });
+
+    return it != m_presets.end() ? &(*it) : nullptr;
+}
+
+DisplayPreset *Presets::findPresetByName(const QString &name)
+{
+    auto it = std::find_if(m_presets.begin(), m_presets.end(), [&name](const DisplayPreset &preset) {
+        return preset.name == name;
+    });
+
+    return it != m_presets.end() ? &(*it) : nullptr;
+}
+
+void Presets::saveToDisk()
+{
+    savePresetsToDisk();
+}
\ No newline at end of file
diff --git a/common/presets.h b/common/presets.h
new file mode 100644
index 00000000..42f861bb
--- /dev/null
+++ b/common/presets.h
@@ -0,0 +1,107 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#pragma once
+
+#include <KScreen/Config>
+#include <KScreen/Mode>
+#include <KScreen/Output>
+
+#include <QAbstractListModel>
+#include <QDateTime>
+#include <QFileSystemWatcher>
+#include <QKeySequence>
+#include <QString>
+#include <QStringList>
+#include <QVariantMap>
+
+struct DisplayPreset {
+    QString id;
+    QString name;
+    QString description;
+    QDateTime created;
+    QDateTime lastUsed;
+    QStringList outputIds;
+    QVariantMap configuration;
+    QKeySequence shortcut;
+
+    bool operator==(const DisplayPreset &other) const
+    {
+        return id == other.id;
+    }
+};
+
+class Presets : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ rowCount NOTIFY presetsChanged)
+    Q_PROPERTY(bool hasPresets READ hasPresets NOTIFY presetsChanged)
+    Q_PROPERTY(KScreen::ConfigPtr screenConfiguration READ screenConfiguration WRITE setScreenConfiguration)
+
+public:
+    enum PresetRoles {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        DescriptionRole,
+        CreatedRole,
+        LastUsedRole,
+        OutputCountRole,
+        ConfigurationRole,
+        ShortcutRole,
+    };
+    Q_ENUM(PresetRoles)
+
+    explicit Presets(QObject *parent = nullptr, const QString &customFilePath = QString());
+    ~Presets() override = default;
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    bool hasPresets() const;
+
+    Q_INVOKABLE bool isPresetAvailable(const QString &presetId) const;
+    Q_INVOKABLE bool isPresetCurrent(const QString &presetId) const;
+    KScreen::ConfigPtr screenConfiguration() const;
+    void setScreenConfiguration(KScreen::ConfigPtr config);
+
+    Q_INVOKABLE DisplayPreset getPreset(const QString &presetId) const;
+    Q_INVOKABLE bool presetExists(const QString &name) const;
+    Q_INVOKABLE void updateLastUsed(const QString &presetId);
+    Q_INVOKABLE void refreshPresetStatus();
+
+    void setCustomPresetsFilePath(const QString &filePath);
+    void reloadPresets();
+
+    // Methods for preset manipulation
+    void addPreset(const DisplayPreset &preset);
+    void updatePreset(const QString &presetId, const DisplayPreset &preset);
+    void removePreset(const QString &presetId);
+    DisplayPreset *findPreset(const QString &presetId);
+    DisplayPreset *findPresetByName(const QString &name);
+    void saveToDisk();
+
+Q_SIGNALS:
+    void presetsChanged();
+    void screenConfigurationChanged();
+    void loadingFailed(const QString &error);
+    void savingFailed(const QString &error);
+
+protected:
+    void loadPresetsFromDisk();
+    void savePresetsToDisk();
+    QString presetsFilePath() const;
+
+private Q_SLOTS:
+    void onPresetFileChanged();
+
+protected:
+    QList<DisplayPreset> m_presets;
+    KScreen::ConfigPtr m_screenConfiguration;
+
+private:
+    QFileSystemWatcher *m_fileWatcher;
+    QString m_customPresetsFilePath;
+};
\ No newline at end of file
diff --git a/kcm/CMakeLists.txt b/kcm/CMakeLists.txt
index 982ca94c..192c72ef 100644
--- a/kcm/CMakeLists.txt
+++ b/kcm/CMakeLists.txt
@@ -6,6 +6,7 @@ target_sources(kcm_kscreen PRIVATE
     config_handler.cpp config_handler.h
     kcm.cpp kcm.h
     output_model.cpp output_model.h
+    preset_manager.cpp preset_manager.h
     ${kwincompositing_SRC}
 )
 
diff --git a/kcm/kcm.cpp b/kcm/kcm.cpp
index dcbd27ec..3bf5b746 100644
--- a/kcm/kcm.cpp
+++ b/kcm/kcm.cpp
@@ -7,10 +7,13 @@
 
 #include "common/control.h"
 #include "common/orientation_sensor.h"
+#include "common/utils.h"
 #include "config_handler.h"
 #include "globalscalesettings.h"
 #include "kcm_screen_debug.h"
 #include "kwincompositing_setting.h"
+#include "output_model.h"
+#include "preset_manager.h"
 
 #include <kscreen/config.h>
 #include <kscreen/configmonitor.h>
@@ -51,11 +54,13 @@ KCMKScreen::KCMKScreen(QObject *parent, const KPluginMetaData &data)
     qmlRegisterUncreatableType<OutputModel>("org.kde.private.kcm.kscreen", 1, 0, "OutputModel", QStringLiteral("For enums"));
     qmlRegisterType<KScreen::Output>("org.kde.private.kcm.kscreen", 1, 0, "Output");
     qmlRegisterUncreatableType<KCMKScreen>("org.kde.private.kcm.kscreen", 1, 0, "KCMKScreen", QStringLiteral("For InvalidConfig enum"));
+    qmlRegisterUncreatableType<PresetManager>("org.kde.private.kcm.kscreen", 1, 0, "PresetManager", QStringLiteral("Preset management"));
     Log::instance();
 
     setButtons(Apply);
 
     m_outputProxyModel = new ScreenSortProxyModel(this);
+    m_presetManager = new PresetManager(this);
 
     m_loadCompressor = new QTimer(this);
     m_loadCompressor->setInterval(1000);
@@ -101,6 +106,9 @@ void KCMKScreen::configReady(ConfigOperation *op)
     Q_EMIT outputReplicationSupportedChanged();
     Q_EMIT tabletModeAvailableChanged();
     Q_EMIT autoRotationSupportedChanged();
+
+    // Update preset status when configuration is ready
+    updatePresetStatus();
 }
 
 void KCMKScreen::save()
@@ -251,6 +259,11 @@ QAbstractItemModel *KCMKScreen::outputModel() const
     return m_outputProxyModel;
 }
 
+QAbstractItemModel *KCMKScreen::presetModel() const
+{
+    return m_presetManager->presetsModel();
+}
+
 void KCMKScreen::identifyOutputs()
 {
     const QString name = QStringLiteral("org.kde.KWin");
@@ -373,6 +386,9 @@ void KCMKScreen::load()
 
         // Reload settings delayed such that daemon can update output values.
         m_loadCompressor->start();
+
+        // Update preset status when displays change
+        updatePresetStatus();
     });
     connect(m_configHandler.get(), &ConfigHandler::screenNormalizationUpdate, this, &KCMKScreen::setScreenNormalized);
 
@@ -559,6 +575,220 @@ void KCMKScreen::startHdrCalibrator(const QString &outputName)
     QProcess::startDetached("hdrcalibrator", {outputName});
 }
 
+void KCMKScreen::savePreset(const QString &name, const QString &description)
+{
+    if (!m_configHandler || !m_configHandler->config()) {
+        return;
+    }
+    m_presetManager->savePreset(name, description, m_configHandler->config());
+}
+
+void KCMKScreen::loadPreset(const QString &presetId)
+{
+    // Validate prerequisites
+    if (!m_configHandler || !m_configHandler->config()) {
+        return;
+    }
+
+    auto preset = m_presetManager->getPreset(presetId);
+    if (preset.id.isEmpty()) {
+        return;
+    }
+
+    auto outputModel = m_configHandler->outputModel();
+    auto currentConfig = m_configHandler->config();
+    if (!outputModel || !currentConfig) {
+        return;
+    }
+
+    // Build lookup map for preset outputs for O(1) access
+    const auto presetOutputsList = preset.configuration[QStringLiteral("outputs")].toList();
+    QHash<QString, QVariantMap> presetOutputsMap;
+    for (const auto &presetOutputVariant : presetOutputsList) {
+        const auto presetOutputMap = presetOutputVariant.toMap();
+        const QString outputName = presetOutputMap[QStringLiteral("name")].toString();
+        presetOutputsMap[outputName] = presetOutputMap;
+    }
+
+    // First pass: Enable/disable outputs and set basic properties
+    for (const auto &currentOutput : currentConfig->outputs()) {
+        const QModelIndex outputIndex = outputModel->indexForOutput(currentOutput);
+        if (!outputIndex.isValid()) {
+            continue;
+        }
+
+        const auto presetOutputIt = presetOutputsMap.find(currentOutput->name());
+        if (presetOutputIt != presetOutputsMap.end()) {
+            applyPresetToOutput(outputModel, outputIndex, currentOutput, currentConfig, *presetOutputIt);
+        } else {
+            // Output not in preset - disable it
+            outputModel->setData(outputIndex, false, OutputModel::EnabledRole);
+        }
+    }
+
+    // Second pass: Set positions after all outputs are configured
+    for (const auto &currentOutput : currentConfig->outputs()) {
+        const QModelIndex outputIndex = outputModel->indexForOutput(currentOutput);
+        if (!outputIndex.isValid()) {
+            continue;
+        }
+
+        const auto presetOutputIt = presetOutputsMap.find(currentOutput->name());
+        if (presetOutputIt != presetOutputsMap.end()) {
+            const auto &presetOutputMap = *presetOutputIt;
+            if (presetOutputMap[QStringLiteral("enabled")].toBool()) {
+                const auto pos = presetOutputMap[QStringLiteral("pos")].toMap();
+                const QPoint newPos(pos[QStringLiteral("x")].toInt(), pos[QStringLiteral("y")].toInt());
+                outputModel->setData(outputIndex, newPos, OutputModel::PositionRole);
+            }
+        }
+    }
+
+    // Finalize preset loading
+    m_presetManager->updateLastUsed(presetId);
+    checkConfig();
+    settingsChanged();
+    Q_EMIT changed();
+    Q_EMIT m_configHandler->outputModelChanged();
+}
+
+void KCMKScreen::applyPresetToOutput(OutputModel *outputModel,
+                                     const QModelIndex &outputIndex,
+                                     const KScreen::OutputPtr &currentOutput,
+                                     const KScreen::ConfigPtr &currentConfig,
+                                     const QVariantMap &presetOutputMap)
+{
+    // First enable the output
+    bool enabled = presetOutputMap[QStringLiteral("enabled")].toBool();
+    outputModel->setData(outputIndex, enabled, OutputModel::EnabledRole);
+
+    // Then set resolution/mode
+    const auto mode = presetOutputMap[QStringLiteral("mode")].toMap();
+    const QString modeId = mode[QStringLiteral("id")].toString();
+    currentOutput->setCurrentModeId(modeId);
+
+    // Set scale
+    qreal scale = presetOutputMap[QStringLiteral("scale")].toReal();
+    outputModel->setData(outputIndex, scale, OutputModel::ScaleRole);
+
+    // Set rotation
+    const auto newRotation = static_cast<KScreen::Output::Rotation>(presetOutputMap[QStringLiteral("rotation")].toInt());
+    outputModel->setData(outputIndex, static_cast<int>(newRotation), OutputModel::RotationRole);
+
+    // Position will be set in second pass
+
+    // Set priority
+    const int newPriority = presetOutputMap[QStringLiteral("priority")].toInt();
+    outputModel->setData(outputIndex, newPriority, OutputModel::PriorityRole);
+
+    // Set primary output if this has priority 1
+    if (newPriority == 1) {
+        currentConfig->setPrimaryOutput(currentOutput);
+    }
+}
+
+void KCMKScreen::deletePreset(const QString &presetId)
+{
+    m_presetManager->deletePreset(presetId);
+}
+
+void KCMKScreen::renamePreset(const QString &presetId, const QString &newName)
+{
+    m_presetManager->renamePreset(presetId, newName);
+}
+
+void KCMKScreen::updatePresetDescription(const QString &presetId, const QString &newDescription)
+{
+    m_presetManager->updatePresetDescription(presetId, newDescription);
+}
+
+void KCMKScreen::updatePresetShortcut(const QString &presetId, const QKeySequence &shortcut)
+{
+    m_presetManager->updatePresetShortcut(presetId, shortcut);
+}
+
+void KCMKScreen::pushPresetPage()
+{
+    push("PresetPage.qml", QVariantMap{{"kcm", QVariant::fromValue(this)}, {"canSavePreset", backendReady()}});
+}
+
+void KCMKScreen::popPage()
+{
+    pop();
+}
+
+bool KCMKScreen::isPresetAvailable(const QString &presetId)
+{
+    if (!m_configHandler || !m_configHandler->config() || !m_presetManager) {
+        return false;
+    }
+
+    DisplayPreset preset = m_presetManager->getPreset(presetId);
+    if (preset.id.isEmpty()) {
+        return false;
+    }
+
+    // Get current configuration
+    auto currentOutputs = m_configHandler->config()->outputs();
+    QStringList currentConnectedIds;
+    for (const auto &output : currentOutputs) {
+        if (output->isConnected()) {
+            currentConnectedIds.append(output->hashMd5());
+        }
+    }
+
+    // Check if all required monitors from preset are currently connected
+    for (const QString &requiredId : preset.outputIds) {
+        if (!currentConnectedIds.contains(requiredId)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool KCMKScreen::isPresetCurrent(const QString &presetId)
+{
+    if (!m_configHandler || !m_configHandler->config() || !m_presetManager) {
+        return false;
+    }
+
+    // Set current screen configuration for the preset manager to compare against
+    m_presetManager->setScreenConfiguration(m_configHandler->config());
+
+    return m_presetManager->isPresetCurrent(presetId);
+}
+
+void KCMKScreen::updatePresetStatus()
+{
+    if (m_presetManager && m_configHandler && m_configHandler->config()) {
+        m_presetManager->setScreenConfiguration(m_configHandler->config());
+        m_presetManager->refreshPresetStatus();
+    }
+}
+
+bool KCMKScreen::isOutputCurrentlyConnected(const QString &outputId)
+{
+    if (!m_configHandler || !m_configHandler->config()) {
+        return false;
+    }
+
+    // Get current configuration
+    auto currentOutputs = m_configHandler->config()->outputs();
+    for (const auto &output : currentOutputs) {
+        if (output->isConnected() && output->hashMd5() == outputId) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+QString KCMKScreen::formatResolution(int width, int height) const
+{
+    return Utils::sizeToString(QSize(width, height));
+}
+
 #include "kcm.moc"
 
 #include "moc_kcm.cpp"
diff --git a/kcm/kcm.h b/kcm/kcm.h
index 773282f8..95c479ee 100644
--- a/kcm/kcm.h
+++ b/kcm/kcm.h
@@ -19,6 +19,7 @@ class ConfigOperation;
 class ConfigHandler;
 class OrientationSensor;
 class OutputIdentifier;
+class PresetManager;
 
 class QSortFilterProxyModel;
 
@@ -41,6 +42,7 @@ class KCMKScreen : public KQuickManagedConfigModule
     Q_PROPERTY(bool xwaylandClientsScale READ xwaylandClientsScale WRITE setXwaylandClientsScale NOTIFY xwaylandClientsScaleChanged)
     Q_PROPERTY(bool tearingAllowed READ allowTearing WRITE setAllowTearing NOTIFY tearingAllowedChanged)
     Q_PROPERTY(bool multipleScreensAvailable READ multipleScreensAvailable NOTIFY multipleScreensAvailableChanged)
+    Q_PROPERTY(QAbstractItemModel *presetModel READ presetModel CONSTANT)
 
 public:
     enum InvalidConfigReason {
@@ -58,6 +60,7 @@ public:
     bool isSaveNeeded() const override;
 
     QAbstractItemModel *outputModel() const;
+    QAbstractItemModel *presetModel() const;
 
     Q_INVOKABLE void identifyOutputs();
 
@@ -96,6 +99,19 @@ public:
 
     Q_INVOKABLE void startHdrCalibrator(const QString &outputName);
 
+    Q_INVOKABLE void savePreset(const QString &name, const QString &description);
+    Q_INVOKABLE void loadPreset(const QString &presetId);
+    Q_INVOKABLE void deletePreset(const QString &presetId);
+    Q_INVOKABLE void renamePreset(const QString &presetId, const QString &newName);
+    Q_INVOKABLE void updatePresetDescription(const QString &presetId, const QString &newDescription);
+    Q_INVOKABLE void updatePresetShortcut(const QString &presetId, const QKeySequence &shortcut);
+    Q_INVOKABLE void pushPresetPage();
+    Q_INVOKABLE void popPage();
+    Q_INVOKABLE bool isPresetAvailable(const QString &presetId);
+    Q_INVOKABLE bool isPresetCurrent(const QString &presetId);
+    Q_INVOKABLE bool isOutputCurrentlyConnected(const QString &outputId);
+    Q_INVOKABLE QString formatResolution(int width, int height) const;
+
 Q_SIGNALS:
     void backendReadyChanged();
     void backendError();
@@ -123,6 +139,7 @@ Q_SIGNALS:
 private:
     void setBackendReady(bool error);
     void setScreenNormalized(bool normalized);
+    void updatePresetStatus();
 
     void exportGlobalScale();
 
@@ -130,6 +147,12 @@ private:
     void continueNeedsSaveCheck(bool needs);
     void checkConfig();
 
+    void applyPresetToOutput(OutputModel *outputModel,
+                             const QModelIndex &outputIndex,
+                             const KScreen::OutputPtr &currentOutput,
+                             const KScreen::ConfigPtr &currentConfig,
+                             const QVariantMap &presetOutputMap);
+
     std::unique_ptr<ConfigHandler> m_configHandler;
     OrientationSensor *m_orientationSensor;
     bool m_backendReady = false;
@@ -140,6 +163,7 @@ private:
     bool m_needsKwinConfigReload = false;
 
     QSortFilterProxyModel *m_outputProxyModel;
+    PresetManager *m_presetManager = nullptr;
 
     QTimer *m_loadCompressor;
 };
diff --git a/kcm/preset_manager.cpp b/kcm/preset_manager.cpp
new file mode 100644
index 00000000..3ea97a48
--- /dev/null
+++ b/kcm/preset_manager.cpp
@@ -0,0 +1,229 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#include "preset_manager.h"
+#include "common/utils.h"
+
+#include <kscreen/edid.h>
+#include <kscreen/mode.h>
+
+#include <KLocalizedString>
+
+#include <QDebug>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QUuid>
+
+PresetManager::PresetManager(QObject *parent)
+    : QObject(parent)
+{
+    m_presets = new Presets(this);
+
+    // Forward signals from Presets
+    connect(m_presets, &Presets::presetsChanged, this, &PresetManager::presetsChanged);
+    connect(m_presets, &Presets::screenConfigurationChanged, this, &PresetManager::screenConfigurationChanged);
+    connect(m_presets, &Presets::loadingFailed, this, &PresetManager::loadingFailed);
+    connect(m_presets, &Presets::savingFailed, this, &PresetManager::savingFailed);
+}
+
+Presets *PresetManager::presetsModel() const
+{
+    return m_presets;
+}
+
+// Presets interface forwarding
+bool PresetManager::hasPresets() const
+{
+    return m_presets->hasPresets();
+}
+
+bool PresetManager::isPresetAvailable(const QString &presetId) const
+{
+    return m_presets->isPresetAvailable(presetId);
+}
+
+bool PresetManager::isPresetCurrent(const QString &presetId) const
+{
+    return m_presets->isPresetCurrent(presetId);
+}
+
+DisplayPreset PresetManager::getPreset(const QString &presetId) const
+{
+    return m_presets->getPreset(presetId);
+}
+
+bool PresetManager::presetExists(const QString &name) const
+{
+    return m_presets->presetExists(name);
+}
+
+void PresetManager::updateLastUsed(const QString &presetId)
+{
+    m_presets->updateLastUsed(presetId);
+}
+
+void PresetManager::refreshPresetStatus()
+{
+    m_presets->refreshPresetStatus();
+}
+
+KScreen::ConfigPtr PresetManager::screenConfiguration() const
+{
+    return m_presets->screenConfiguration();
+}
+
+void PresetManager::setScreenConfiguration(KScreen::ConfigPtr config)
+{
+    m_presets->setScreenConfiguration(config);
+}
+
+void PresetManager::savePreset(const QString &name, const QString &description, KScreen::ConfigPtr config)
+{
+    if (!config) {
+        Q_EMIT errorOccurred(i18n("Invalid configuration"));
+        return;
+    }
+
+    // Generate a unique ID for the preset
+    const QString presetId = generatePresetId();
+
+    // Create the preset
+    DisplayPreset preset;
+    preset.id = presetId;
+    preset.name = name;
+    preset.description = description;
+    preset.created = QDateTime::currentDateTime();
+    preset.lastUsed = QDateTime::currentDateTime();
+    preset.configuration = configToVariantMap(config);
+
+    // Extract output IDs
+    for (const auto &output : config->outputs()) {
+        if (output->isEnabled()) {
+            preset.outputIds.append(output->hashMd5());
+        }
+    }
+
+    // Check if preset with same name exists and replace it
+    DisplayPreset *existingPreset = m_presets->findPresetByName(name);
+
+    if (existingPreset) {
+        // Replace existing preset
+        preset.created = existingPreset->created; // Keep original creation date
+        m_presets->updatePreset(existingPreset->id, preset);
+    } else {
+        // Add new preset
+        m_presets->addPreset(preset);
+    }
+
+    m_presets->saveToDisk();
+    Q_EMIT presetSaved(presetId);
+}
+
+void PresetManager::deletePreset(const QString &presetId)
+{
+    m_presets->removePreset(presetId);
+    m_presets->saveToDisk();
+    Q_EMIT presetDeleted(presetId);
+}
+
+void PresetManager::renamePreset(const QString &presetId, const QString &newName)
+{
+    DisplayPreset *preset = m_presets->findPreset(presetId);
+    if (preset) {
+        preset->name = newName;
+        m_presets->saveToDisk();
+    }
+}
+
+void PresetManager::updatePresetDescription(const QString &presetId, const QString &newDescription)
+{
+    DisplayPreset *preset = m_presets->findPreset(presetId);
+    if (preset) {
+        preset->description = newDescription;
+        m_presets->saveToDisk();
+    }
+}
+
+void PresetManager::updatePresetShortcut(const QString &presetId, const QKeySequence &shortcut)
+{
+    DisplayPreset *preset = m_presets->findPreset(presetId);
+    if (preset) {
+        preset->shortcut = shortcut;
+        m_presets->saveToDisk();
+    }
+}
+
+QString PresetManager::generatePresetId() const
+{
+    return QUuid::createUuid().toString(QUuid::WithoutBraces);
+}
+
+QVariantMap PresetManager::configToVariantMap(KScreen::ConfigPtr config) const
+{
+    QVariantMap configMap;
+
+    // Store supported features
+    configMap[QStringLiteral("features")] = static_cast<int>(config->supportedFeatures());
+    configMap[QStringLiteral("tabletModeEngaged")] = config->tabletModeEngaged();
+
+    // Store outputs
+    QVariantList outputsList;
+    for (const auto &output : config->outputs()) {
+        QVariantMap outputMap;
+        outputMap[QStringLiteral("id")] = output->hashMd5();
+        outputMap[QStringLiteral("name")] = output->name();
+        outputMap[QStringLiteral("model")] = output->model();
+        outputMap[QStringLiteral("vendor")] = output->vendor();
+        outputMap[QStringLiteral("type")] = static_cast<int>(output->type());
+        outputMap[QStringLiteral("displayName")] = Utils::outputName(output.get());
+        outputMap[QStringLiteral("connected")] = output->isConnected();
+        outputMap[QStringLiteral("enabled")] = output->isEnabled();
+        outputMap[QStringLiteral("primary")] = output->isPrimary();
+        outputMap[QStringLiteral("priority")] = output->priority();
+
+        // Position and size
+        outputMap[QStringLiteral("pos")] = QVariantMap{{QStringLiteral("x"), output->pos().x()}, {QStringLiteral("y"), output->pos().y()}};
+        outputMap[QStringLiteral("scale")] = output->scale();
+        outputMap[QStringLiteral("rotation")] = static_cast<int>(output->rotation());
+
+        // Logical size (for plasmoid)
+        const QSizeF logicalSize = output->explicitLogicalSize();
+        if (!logicalSize.isEmpty()) {
+            outputMap[QStringLiteral("explicitLogicalSize")] = true;
+            outputMap[QStringLiteral("logicalSize")] =
+                QVariantMap{{QStringLiteral("width"), logicalSize.width()}, {QStringLiteral("height"), logicalSize.height()}};
+        } else {
+            outputMap[QStringLiteral("explicitLogicalSize")] = false;
+        }
+
+        // Mode
+        if (output->currentMode()) {
+            QVariantMap modeMap;
+            modeMap[QStringLiteral("id")] = output->currentModeId();
+            modeMap[QStringLiteral("width")] = output->currentMode()->size().width();
+            modeMap[QStringLiteral("height")] = output->currentMode()->size().height();
+            modeMap[QStringLiteral("refreshRate")] = output->currentMode()->refreshRate();
+            outputMap[QStringLiteral("mode")] = modeMap;
+        }
+
+        // Additional settings
+        outputMap[QStringLiteral("overscan")] = output->overscan();
+        outputMap[QStringLiteral("vrrPolicy")] = static_cast<int>(output->vrrPolicy());
+        outputMap[QStringLiteral("rgbRange")] = static_cast<int>(output->rgbRange());
+        outputMap[QStringLiteral("hdr")] = output->isHdrEnabled();
+        outputMap[QStringLiteral("sdr_brightness")] = output->sdrBrightness();
+        outputMap[QStringLiteral("wide_color_gamut")] = output->isWcgEnabled();
+        outputMap[QStringLiteral("icc_profile_path")] = output->iccProfilePath();
+        outputMap[QStringLiteral("brightness")] = output->brightness();
+        outputMap[QStringLiteral("auto_rotate_policy")] = static_cast<int>(output->autoRotatePolicy());
+        outputMap[QStringLiteral("capabilities")] = static_cast<int>(output->capabilities());
+        outputMap[QStringLiteral("edr_policy")] = static_cast<int>(output->edrPolicy());
+
+        outputsList.append(outputMap);
+    }
+    configMap[QStringLiteral("outputs")] = outputsList;
+
+    return configMap;
+}
\ No newline at end of file
diff --git a/kcm/preset_manager.h b/kcm/preset_manager.h
new file mode 100644
index 00000000..aa44ad76
--- /dev/null
+++ b/kcm/preset_manager.h
@@ -0,0 +1,57 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#pragma once
+
+#include "common/presets.h"
+#include <QAbstractListModel>
+#include <kscreen/config.h>
+
+class PresetManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit PresetManager(QObject *parent = nullptr);
+    ~PresetManager() override = default;
+
+    // Get the presets model for QML
+    Q_INVOKABLE Presets *presetsModel() const;
+
+    // Presets interface forwarding
+    Q_INVOKABLE bool hasPresets() const;
+    Q_INVOKABLE bool isPresetAvailable(const QString &presetId) const;
+    Q_INVOKABLE bool isPresetCurrent(const QString &presetId) const;
+    Q_INVOKABLE DisplayPreset getPreset(const QString &presetId) const;
+    Q_INVOKABLE bool presetExists(const QString &name) const;
+    Q_INVOKABLE void updateLastUsed(const QString &presetId);
+    Q_INVOKABLE void refreshPresetStatus();
+
+    KScreen::ConfigPtr screenConfiguration() const;
+    void setScreenConfiguration(KScreen::ConfigPtr config);
+
+    Q_INVOKABLE void savePreset(const QString &name, const QString &description, KScreen::ConfigPtr config);
+    Q_INVOKABLE void deletePreset(const QString &presetId);
+    Q_INVOKABLE void renamePreset(const QString &presetId, const QString &newName);
+    Q_INVOKABLE void updatePresetDescription(const QString &presetId, const QString &newDescription);
+    Q_INVOKABLE void updatePresetShortcut(const QString &presetId, const QKeySequence &shortcut);
+
+Q_SIGNALS:
+    void presetSaved(const QString &presetId);
+    void presetDeleted(const QString &presetId);
+    void errorOccurred(const QString &error);
+
+    // Forward signals from Presets
+    void presetsChanged();
+    void screenConfigurationChanged();
+    void loadingFailed(const QString &error);
+    void savingFailed(const QString &error);
+
+private:
+    QString generatePresetId() const;
+    QVariantMap configToVariantMap(KScreen::ConfigPtr config) const;
+
+    Presets *m_presets = nullptr;
+};
\ No newline at end of file
diff --git a/kcm/ui/PresetOutput.qml b/kcm/ui/PresetOutput.qml
new file mode 100644
index 00000000..0e4a13de
--- /dev/null
+++ b/kcm/ui/PresetOutput.qml
@@ -0,0 +1,198 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+    Based on Output.qml by Roman Gilg, Dan Vratil, and Kai Uwe Broulik
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+import QtQuick 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Controls 2.15 as QQC2
+import org.kde.kirigami 2.20 as Kirigami
+import org.kde.private.kcm.kscreen 1.0 as KScreen
+
+Item {
+    id: presetOutput
+
+    property var outputData: null
+    property var kcm: null
+    property real scaleFactor: 1.0
+    property real xOffset: 0
+    property real yOffset: 0
+    property var bounds: ({ minX: 0, minY: 0, maxX: 1920, maxY: 1080 })
+
+    // Force refresh when monitor connection state changes
+    property bool _refreshTrigger: false
+
+    readonly property var pos: outputData?.pos || { x: 0, y: 0 }
+    readonly property var mode: outputData?.mode || { width: 1920, height: 1080 }
+    readonly property real scale: outputData?.scale || 1
+    readonly property real monitorWidth: mode.width / scale
+    readonly property real monitorHeight: mode.height / scale
+    readonly property bool outputAvailable: {
+        _refreshTrigger; // Force binding update
+        return !kcm || kcm.isOutputCurrentlyConnected(outputData?.id || "");
+    }
+
+    // Connect to monitor connection changes
+    Connections {
+        target: kcm
+        function onOutputConnect() {
+            _refreshTrigger = !_refreshTrigger;
+        }
+    }
+
+    visible: outputData?.enabled !== false
+    x: ((pos.x || 0) - bounds.minX) * scaleFactor + xOffset
+    y: ((pos.y || 0) - bounds.minY) * scaleFactor + yOffset
+    width: monitorWidth * scaleFactor
+    height: monitorHeight * scaleFactor
+    opacity: outputAvailable ? 1.0 : 0.4
+
+    Rectangle {
+        id: outline
+        anchors.centerIn: parent
+        width: parent.width
+        height: parent.height
+        radius: 2
+        color: outputAvailable ? Kirigami.Theme.backgroundColor : Kirigami.Theme.disabledTextColor
+        border.color: outputAvailable ? Kirigami.Theme.textColor : Kirigami.Theme.disabledTextColor
+        border.width: 2
+
+        // Simple bottom bar as orientation indicator
+        Rectangle {
+            anchors {
+                left: parent.left
+                right: parent.right
+                bottom: parent.bottom
+                margins: 1
+            }
+            height: 2
+            color: parent.border.color
+        }
+
+        // Priority number in top-right corner
+        Rectangle {
+            anchors {
+                top: parent.top
+                right: parent.right
+                margins: 2
+            }
+            width: priorityText.width + 4
+            height: priorityText.height + 2
+            radius: 2
+            color: Kirigami.Theme.highlightColor
+            visible: parent.width > 30 && parent.height > 20
+
+            Text {
+                id: priorityText
+                anchors.centerIn: parent
+                text: presetOutput.outputData?.priority || "1"
+                color: Kirigami.Theme.highlightedTextColor
+                font.pixelSize: Math.max(6, Math.min(10, parent.parent.parent.height / 8))
+                font.bold: true
+            }
+        }
+
+        // Monitor info text - responsive to scaled size
+        Column {
+            anchors.centerIn: parent
+            spacing: Math.max(1, parent.height / 15)
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                width: parent.parent.width - 4
+                text: {
+                    // Use displayName if available (generated by Utils::outputName())
+                    var displayName = presetOutput.outputData?.displayName;
+                    if (displayName) {
+                        return displayName;
+                    }
+
+                    var name = "";
+                    var vendor = presetOutput.outputData?.vendor || "";
+                    var model = presetOutput.outputData?.model || "";
+
+                    if (vendor) {
+                        name = vendor + " ";
+                    }
+                    if (model) {
+                        name += model + " ";
+                    }
+
+                    if (name.trim()) {
+                        return name.trim();
+                    }
+
+                    return presetOutput.outputData?.name || i18nc("@label default monitor name", "Monitor");
+                }
+                color: outputAvailable ? Kirigami.Theme.textColor : Kirigami.Theme.disabledTextColor
+                font.pixelSize: Math.max(6, Math.min(12, parent.parent.height / 5))
+                font.bold: false
+                horizontalAlignment: Text.AlignHCenter
+                wrapMode: Text.Wrap
+                maximumLineCount: 2
+                visible: parent.parent.height > 15
+            }
+
+            // Missing monitor indicator or technical details
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: {
+                    if (!outputAvailable) {
+                        return i18nc("@info Monitor is not currently connected", "Missing");
+                    }
+
+                    // Use Utils::sizeToString() for consistent formatting
+                    var res = presetOutput.kcm ?
+                        presetOutput.kcm.formatResolution(mode.width || 1920, mode.height || 1080) :
+                        (mode.width || 1920) + "×" + (mode.height || 1080);
+                    var refresh = Math.round(mode.refreshRate || 60) + "Hz";
+                    var extras = [];
+
+                    // Get monitor capabilities
+                    var capabilities = presetOutput.outputData?.capabilities || 0;
+
+                    // Check for HDR - monitor must support it and have it enabled
+                    var supportsHdr = (capabilities & KScreen.Output.Capability.HighDynamicRange) !== 0;
+                    if (presetOutput.outputData?.hdr && supportsHdr) {
+                        extras.push("<b>" + i18nc("@label HDR indicator", "HDR") + "</b>");
+                    }
+
+                    // Check for EDR policy - 1 means Always enabled, and monitor must support EDR
+                    var edrPolicy = presetOutput.outputData?.edr_policy;
+                    var supportsEdr = (capabilities & KScreen.Output.Capability.ExtendedDynamicRange) !== 0;
+                    if (edrPolicy === 1 && supportsEdr) {
+                        extras.push("<b>" + i18nc("@label EDR indicator", "EDR") + "</b>");
+                    }
+
+                    var result = res + " " + refresh;
+                    if (extras.length > 0) {
+                        result += " " + extras.join(" ");
+                    }
+
+                    return result;
+                }
+                color: outputAvailable ? Kirigami.Theme.textColor : Kirigami.Theme.disabledTextColor
+                font.pixelSize: Math.max(5, Math.min(10, parent.parent.height / 6))
+                opacity: outputAvailable ? 0.8 : 0.7
+                horizontalAlignment: Text.AlignHCenter
+                elide: Text.ElideRight
+                textFormat: Text.RichText
+                visible: parent.parent.height > 20
+            }
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: {
+                    var scale = presetOutput.outputData?.scale || 1;
+                    return i18nc("@info monitor scale factor", "Scale: %1%", Math.round(scale * 100));
+                }
+                color: outputAvailable ? Kirigami.Theme.textColor : Kirigami.Theme.disabledTextColor
+                font.pixelSize: Math.max(5, Math.min(9, parent.parent.height / 7))
+                opacity: 0.7
+                horizontalAlignment: Text.AlignHCenter
+                visible: parent.parent.height > 25 && outputAvailable
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/kcm/ui/PresetPage.qml b/kcm/ui/PresetPage.qml
new file mode 100644
index 00000000..69522cd4
--- /dev/null
+++ b/kcm/ui/PresetPage.qml
@@ -0,0 +1,356 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+import QtQuick 2.15
+import QtQuick.Layouts
+import QtQuick.Controls 2.15 as QQC2
+import org.kde.kirigami 2.20 as Kirigami
+import org.kde.kcmutils as KCM
+import org.kde.kquickcontrols
+import org.kde.private.kcm.kscreen 1.0 as KScreen
+
+KCM.SimpleKCM {
+    id: presetPage
+
+    property var kcm
+    property bool canSavePreset: true
+
+    // Force refresh when monitor connection state changes
+    property bool _refreshTrigger: false
+
+    title: i18nc("@title:window Display presets management", "Presets")
+
+    // Connect to monitor connection changes to refresh preset availability
+    Connections {
+        target: kcm
+        function onOutputConnect() {
+            _refreshTrigger = !_refreshTrigger;
+        }
+    }
+    
+    actions: Kirigami.Action {
+        text: i18nc("@action:button Save current display configuration", "Save Current…")
+        icon.name: "list-add"
+        enabled: canSavePreset
+        onTriggered: savePresetDialog.open()
+    }
+
+    
+    ListView {
+        id: presetListView
+        
+        anchors.fill: parent
+        clip: true
+        model: kcm ? kcm.presetModel : null
+        
+        delegate: QQC2.ItemDelegate {
+            width: ListView.view.width
+            height: Math.max(Kirigami.Units.gridUnit * 5, buttonColumn.implicitHeight + Kirigami.Units.largeSpacing * 2)
+
+            contentItem: RowLayout {
+                spacing: Kirigami.Units.largeSpacing
+
+                ColumnLayout {
+                    Layout.preferredWidth: Kirigami.Units.gridUnit * 10
+                    Layout.maximumWidth: Kirigami.Units.gridUnit * 12
+                    spacing: 2
+
+                    QQC2.Label {
+                        Layout.fillWidth: true
+                        text: model.name || i18nc("@label Fallback name for preset without name", "Unnamed Preset")
+                        textFormat: Text.PlainText
+                        elide: Text.ElideRight
+                        font.bold: true
+                    }
+
+                    QQC2.Label {
+                        Layout.fillWidth: true
+                        text: {
+                            var description = model.description || "";
+                            var count = i18nc("@info Number of displays in preset", "%1 display(s)", model.outputCount || 0);
+
+                            if (description) {
+                                return description + " • " + count;
+                            } else {
+                                return count;
+                            }
+                        }
+                        textFormat: Text.PlainText
+                        opacity: 0.6
+                        font.pointSize: Kirigami.Theme.smallFont.pointSize
+                        elide: Text.ElideRight
+                    }
+
+                    QQC2.Label {
+                        Layout.fillWidth: true
+                        text: model.lastUsed ? i18nc("@info", "Last used: %1", Qt.formatDate(model.lastUsed, Qt.DefaultLocaleShortDate)) : i18nc("@info", "Never used")
+                        opacity: 0.6
+                        font.pointSize: Kirigami.Theme.smallFont.pointSize
+                        elide: Text.ElideRight
+                    }
+
+
+                    QQC2.Label {
+                        Layout.fillWidth: true
+                        text: i18nc("@info", "Some monitors unavailable")
+                        color: Kirigami.Theme.negativeTextColor
+                        font.pointSize: Kirigami.Theme.smallFont.pointSize
+                        elide: Text.ElideRight
+                        visible: {
+                            _refreshTrigger; // Force binding update
+                            return kcm && !kcm.isPresetAvailable(model.presetId);
+                        }
+                    }
+                }
+
+                // Monitor layout visualization - constrained to available space
+                Item {
+                    Layout.fillWidth: true
+                    Layout.fillHeight: true
+                    clip: true  // Prevent overflow
+
+                    PresetView {
+                        anchors.fill: parent
+                        // Ensure outputs is correctly passed as array
+                        outputs: {
+                            return model.configuration ? model.configuration.outputs : [];
+                        }
+                        presetAvailable: {
+                            _refreshTrigger; // Force binding update
+                            return !kcm || kcm.isPresetAvailable(model.presetId);
+                        }
+                        kcm: presetPage.kcm
+                    }
+                }
+
+                ColumnLayout {
+                    id: buttonColumn
+                    spacing: Kirigami.Units.smallSpacing
+                    Layout.alignment: Qt.AlignVCenter
+                    Layout.preferredWidth: Kirigami.Units.gridUnit * 9
+                    Layout.maximumWidth: Kirigami.Units.gridUnit * 10
+
+                    QQC2.Button {
+                        id: loadButton
+                        Layout.fillWidth: true
+                        Layout.preferredWidth: Kirigami.Units.gridUnit * 8
+                        text: {
+                            _refreshTrigger; // Force binding update
+                            return kcm && kcm.isPresetCurrent && kcm.isPresetCurrent(model.presetId)
+                                  ? i18nc("@info:status Current preset is active", "Current")
+                                  : i18nc("@action:button Load display preset", "Load");
+                        }
+                        icon.name: {
+                            _refreshTrigger; // Force binding update
+                            return kcm && kcm.isPresetCurrent && kcm.isPresetCurrent(model.presetId)
+                                   ? "checkmark"
+                                   : "document-open";
+                        }
+                        display: QQC2.AbstractButton.TextBesideIcon
+                        enabled: {
+                            _refreshTrigger; // Force binding update
+                            return kcm && kcm.isPresetAvailable && kcm.isPresetAvailable(model.presetId) &&
+                                   (!kcm.isPresetCurrent || !kcm.isPresetCurrent(model.presetId));
+                        }
+                        onClicked: {
+                            if (kcm && typeof kcm.loadPreset === "function") {
+                                kcm.loadPreset(model.presetId)
+                                kcm.popPage()
+                            }
+                        }
+
+                        QQC2.ToolTip.text: {
+                            _refreshTrigger; // Force binding update
+                            return kcm && kcm.isPresetCurrent && kcm.isPresetCurrent(model.presetId)
+                                   ? i18nc("@info:tooltip", "This display preset is currently active")
+                                   : i18nc("@info:tooltip", "Load this display preset configuration");
+                        }
+                        QQC2.ToolTip.visible: hovered
+                        QQC2.ToolTip.delay: 1000
+                    }
+
+                    QQC2.Button {
+                        text: i18nc("@action:button Edit preset properties", "Edit")
+                        icon.name: "document-edit"
+                        display: QQC2.AbstractButton.TextBesideIcon
+                        Layout.fillWidth: true
+                        Layout.preferredWidth: Kirigami.Units.gridUnit * 8
+                        onClicked: {
+                            editPresetDialog.presetId = model.presetId;
+                            editPresetDialog.presetName = model.name || "";
+                            editPresetDialog.presetDescription = model.description || "";
+                            editPresetDialog.open();
+                        }
+
+                        QQC2.ToolTip.text: i18nc("@info:tooltip", "Edit the name and description of this preset")
+                        QQC2.ToolTip.visible: hovered
+                        QQC2.ToolTip.delay: 1000
+                    }
+
+                    QQC2.Button {
+                        text: i18nc("@action:button Delete preset", "Delete")
+                        icon.name: "edit-delete"
+                        display: QQC2.AbstractButton.TextBesideIcon
+                        Layout.fillWidth: true
+                        Layout.preferredWidth: Kirigami.Units.gridUnit * 8
+                        onClicked: {
+                            deleteConfirmDialog.presetId = model.presetId;
+                            deleteConfirmDialog.presetName = model.name || i18nc("@label", "Unnamed Preset");
+                            deleteConfirmDialog.open();
+                        }
+
+                        QQC2.ToolTip.text: i18nc("@info:tooltip", "Delete this display preset permanently")
+                        QQC2.ToolTip.visible: hovered
+                        QQC2.ToolTip.delay: 1000
+                    }
+
+                    KeySequenceItem {
+                        id: shortcutItem
+                        Layout.alignment: Qt.AlignRight
+                        Layout.preferredWidth: Kirigami.Units.gridUnit * 8
+                        keySequence: model.shortcut || ""
+                        patterns: ShortcutPattern.ModifierAndKey | ShortcutPattern.Modifier
+                        multiKeyShortcutsAllowed: false
+                        checkForConflictsAgainst: ShortcutType.Global
+                        onCaptureFinished: {
+                            if (kcm && typeof kcm.updatePresetShortcut === "function") {
+                                kcm.updatePresetShortcut(model.presetId, keySequence)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        Kirigami.PlaceholderMessage {
+            anchors.centerIn: parent
+            width: parent.width - (Kirigami.Units.largeSpacing * 4)
+            visible: presetListView.count === 0
+            text: i18nc("@info", "No display presets saved")
+            explanation: i18nc("@info", "Save your current display configuration to quickly restore it later")
+            icon.name: "view-list-symbolic"
+            
+            helpfulAction: Kirigami.Action {
+                text: i18nc("@action:button", "Save Current Configuration")
+                icon.name: "document-save"
+                enabled: canSavePreset
+                onTriggered: savePresetDialog.open()
+            }
+        }
+    }
+    
+    Kirigami.PromptDialog {
+        id: deleteConfirmDialog
+        
+        property string presetId
+        property string presetName
+        
+        title: i18nc("@title:window", "Delete Preset")
+        subtitle: i18nc("%1 is a preset name",
+                       "Do you want to delete preset '%1'?", presetName)
+        
+        dialogType: Kirigami.PromptDialog.Warning
+        
+        standardButtons: Kirigami.Dialog.Cancel
+        customFooterActions: [
+            Kirigami.Action {
+                text: i18nc("@action:button", "Delete Preset")
+                icon.name: "edit-delete"
+                onTriggered: {
+                    if (kcm && typeof kcm.deletePreset === "function") {
+                        kcm.deletePreset(deleteConfirmDialog.presetId)
+                    }
+                    deleteConfirmDialog.close()
+                }
+            }
+        ]
+    }
+    
+    Kirigami.Dialog {
+        id: savePresetDialog
+        
+        title: i18nc("@title:window", "Save Display Preset")
+        standardButtons: Kirigami.Dialog.Ok | Kirigami.Dialog.Cancel
+        
+        preferredWidth: Kirigami.Units.gridUnit * 20
+        
+        Kirigami.FormLayout {
+            QQC2.TextField {
+                id: presetNameField
+                Kirigami.FormData.label: i18nc("@label:textbox", "Name:")
+                placeholderText: i18nc("@info:placeholder", "Enter preset name")
+                Layout.fillWidth: true
+            }
+            
+            QQC2.TextArea {
+                id: presetDescriptionField
+                Kirigami.FormData.label: i18nc("@label:textbox", "Description:")
+                placeholderText: i18nc("@info:placeholder", "Optional description")
+                wrapMode: Text.Wrap
+                Layout.fillWidth: true
+                Layout.preferredHeight: Kirigami.Units.gridUnit * 3
+            }
+        }
+        
+        onAccepted: {
+            if (presetNameField.text.trim() !== "") {
+                if (kcm && typeof kcm.savePreset === "function") {
+                    kcm.savePreset(presetNameField.text.trim(), presetDescriptionField.text.trim())
+                }
+                presetNameField.clear()
+                presetDescriptionField.clear()
+            }
+        }
+    }
+
+    Kirigami.Dialog {
+        id: editPresetDialog
+
+        property string presetId
+        property string presetName
+        property string presetDescription
+
+        title: i18nc("@title:window", "Edit Preset")
+        standardButtons: Kirigami.Dialog.Ok | Kirigami.Dialog.Cancel
+
+        preferredWidth: Kirigami.Units.gridUnit * 20
+
+        Kirigami.FormLayout {
+            QQC2.TextField {
+                id: editNameField
+                Kirigami.FormData.label: i18nc("@label:textbox", "Name:")
+                placeholderText: i18nc("@info:placeholder", "Enter preset name")
+                Layout.fillWidth: true
+                text: editPresetDialog.presetName
+            }
+
+            QQC2.TextArea {
+                id: editDescriptionField
+                Kirigami.FormData.label: i18nc("@label:textbox", "Description:")
+                placeholderText: i18nc("@info:placeholder", "Optional description")
+                wrapMode: Text.Wrap
+                Layout.fillWidth: true
+                Layout.preferredHeight: Kirigami.Units.gridUnit * 3
+                text: editPresetDialog.presetDescription
+            }
+        }
+
+        onAccepted: {
+            if (editNameField.text.trim() !== "") {
+                // Update name if changed
+                if (editNameField.text.trim() !== editPresetDialog.presetName &&
+                    kcm && typeof kcm.renamePreset === "function") {
+                    kcm.renamePreset(editPresetDialog.presetId, editNameField.text.trim())
+                }
+
+                // Update description if changed
+                if (editDescriptionField.text.trim() !== editPresetDialog.presetDescription &&
+                    kcm && typeof kcm.updatePresetDescription === "function") {
+                    kcm.updatePresetDescription(editPresetDialog.presetId, editDescriptionField.text.trim())
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/kcm/ui/PresetView.qml b/kcm/ui/PresetView.qml
new file mode 100644
index 00000000..cd62b63d
--- /dev/null
+++ b/kcm/ui/PresetView.qml
@@ -0,0 +1,95 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+    Based on ScreenView.qml by Roman Gilg
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+import QtQuick 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Controls 2.15 as QQC2
+import org.kde.kirigami 2.20 as Kirigami
+
+Item {
+    id: presetView
+
+    property var outputs: []
+    property bool presetAvailable: true
+    property var kcm: null
+
+    // Calculate bounds for real positioning
+    readonly property var bounds: {
+        if (!outputs || outputs.length === 0) {
+            return { minX: 0, minY: 0, maxX: 1920, maxY: 1080 };
+        }
+
+        var minX = 999999, minY = 999999, maxX = -999999, maxY = -999999;
+
+        for (var i = 0; i < outputs.length; i++) {
+            var output = outputs[i];
+            if (!output.enabled) continue;
+
+            var pos = output.pos || { x: 0, y: 0 };
+            var mode = output.mode || { width: 1920, height: 1080 };
+            var scale = output.scale || 1;
+
+            var w = mode.width / scale;
+            var h = mode.height / scale;
+            var x = pos.x || 0;
+            var y = pos.y || 0;
+
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x + w);
+            maxY = Math.max(maxY, y + h);
+        }
+
+        if (minX === 999999) {
+            return { minX: 0, minY: 0, maxX: 1920, maxY: 1080 };
+        }
+
+        return { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
+    }
+
+    readonly property real layoutWidth: bounds.maxX - bounds.minX
+    readonly property real layoutHeight: bounds.maxY - bounds.minY
+
+    // Scale to fit container - similar to ScreenView's relativeFactor
+    readonly property real scaleFactor: {
+        if (layoutWidth <= 0 || layoutHeight <= 0 || width <= 0 || height <= 0) {
+            return 0.1;
+        }
+        var margin = 5;
+        var scaleX = (width - margin * 2) / layoutWidth;
+        var scaleY = (height - margin * 2) / layoutHeight;
+        var finalScale = Math.min(scaleX, scaleY);
+
+        return finalScale;
+    }
+
+    readonly property real xOffset: 10
+    readonly property real yOffset: (height - layoutHeight * scaleFactor) / 2
+
+    // Real positioned monitors using Repeater with PresetOutput delegate
+    Repeater {
+        model: outputs
+
+        delegate: PresetOutput {
+            outputData: modelData
+            kcm: presetView.kcm
+            scaleFactor: presetView.scaleFactor
+            xOffset: presetView.xOffset
+            yOffset: presetView.yOffset
+            bounds: presetView.bounds
+        }
+    }
+
+    // Placeholder when no outputs - similar to ScreenView pattern
+    Kirigami.Icon {
+        anchors.centerIn: parent
+        width: Math.min(parent.width * 0.5, Kirigami.Units.iconSizes.medium)
+        height: width
+        source: "computer"
+        opacity: 0.3
+        visible: !outputs || outputs.length === 0
+    }
+}
\ No newline at end of file
diff --git a/kcm/ui/ScreenView.qml b/kcm/ui/ScreenView.qml
index fb153c2e..007cf929 100644
--- a/kcm/ui/ScreenView.qml
+++ b/kcm/ui/ScreenView.qml
@@ -23,6 +23,13 @@ QQC2.ScrollView {
     onWidthChanged: resetTotalSize()
     onHeightChanged: resetTotalSize()
 
+    Connections {
+        target: kcm.configHandler
+        function onOutputModelChanged() {
+            resetTotalSize();
+        }
+    }
+
     readonly property real relativeFactor: {
         const relativeSize = Qt.size(
             totalSize.width / (0.6 * width),
diff --git a/kcm/ui/main.qml b/kcm/ui/main.qml
index 4fb182c3..02110a30 100644
--- a/kcm/ui/main.qml
+++ b/kcm/ui/main.qml
@@ -39,12 +39,19 @@ KCM.AbstractKCM {
     implicitWidth: Kirigami.Units.gridUnit * 32
     implicitHeight: Kirigami.Units.gridUnit * 30
 
-    actions: Kirigami.Action {
-        text: i18nc("@action:button Briefly show the display name in a popup label on each screen", "Identify Screens")
-        icon.name: "documentinfo-symbolic"
-        visible: kcm.multipleScreensAvailable
-        onTriggered: kcm.identifyOutputs()
-    }
+    actions: [
+        Kirigami.Action {
+            text: i18nc("@action:button", "Presets")
+            icon.name: "bookmarks"
+            onTriggered: kcm.pushPresetPage()
+        },
+        Kirigami.Action {
+            text: i18nc("@action:button Briefly show the display name in a popup label on each screen", "Identify Screens")
+            icon.name: "documentinfo-symbolic"
+            visible: kcm.multipleScreensAvailable
+            onTriggered: kcm.identifyOutputs()
+        }
+    ]
 
     topPadding: 0
     leftPadding: 0
diff --git a/kded/CMakeLists.txt b/kded/CMakeLists.txt
index d06fd6c1..43e16d69 100644
--- a/kded/CMakeLists.txt
+++ b/kded/CMakeLists.txt
@@ -29,6 +29,7 @@ target_link_libraries(kscreen PRIVATE
                               KF6::DBusAddons
                               KF6::I18n
                               KF6::XmlGui
+                              KF6::GlobalAccel
 )
 
 if(WITH_X11)
diff --git a/plasmoid/CMakeLists.txt b/plasmoid/CMakeLists.txt
index a428b184..a5bf2ca1 100644
--- a/plasmoid/CMakeLists.txt
+++ b/plasmoid/CMakeLists.txt
@@ -1,17 +1,30 @@
 add_definitions(-DTRANSLATION_DOMAIN=\"plasma_applet_org.kde.kscreen\")
 
+ecm_qt_declare_logging_category(org.kde.kscreen
+  HEADER kscreen_applet_debug.h
+  IDENTIFIER KSCREEN_APPLET
+  CATEGORY_NAME kscreen.applet
+  DESCRIPTION "kscreen plasmoid (kscreen)"
+  EXPORT KSCREEN
+)
+
 plasma_add_applet(org.kde.kscreen
   QML_SOURCES
     main.qml
     InhibitionHint.qml
     PresentationModeItem.qml
     ScreenLayoutSelection.qml
+    PresetList.qml
+    PresetView.qml
+    PresetOutput.qml
   CPP_SOURCES
     kscreenapplet.cpp
+    kscreen_applet_debug.cpp
 )
 
 target_link_libraries(org.kde.kscreen PRIVATE
                       Qt::Qml
+                      Qt::DBus
                       KF6::I18n
                       Plasma::Plasma
                       KF6::Screen
diff --git a/plasmoid/PresetList.qml b/plasmoid/PresetList.qml
new file mode 100644
index 00000000..6cc35c29
--- /dev/null
+++ b/plasmoid/PresetList.qml
@@ -0,0 +1,239 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+*/
+
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls as QQC2
+
+import org.kde.kirigami as Kirigami
+import org.kde.plasma.components as PlasmaComponents
+
+ColumnLayout {
+    id: presetList
+
+    property alias model: listView.model
+    property var loadPresetFunc
+
+    spacing: Kirigami.Units.smallSpacing
+
+    // Shared timer for all preview popups
+    Timer {
+        id: sharedHoverTimer
+        interval: 500
+        property var targetPopup: null
+
+        onTriggered: {
+            if (targetPopup) {
+                targetPopup.open()
+            }
+        }
+    }
+
+    PlasmaComponents.Label {
+        text: i18nc("@title:group", "Presets")
+        font.bold: true
+        Layout.fillWidth: true
+    }
+
+
+
+    ListView {
+        id: listView
+        Layout.fillWidth: true
+        Layout.preferredHeight: Math.max(contentHeight, Kirigami.Units.gridUnit * 3)
+
+        clip: true
+        boundsBehavior: Flickable.StopAtBounds
+
+
+        delegate: PlasmaComponents.ItemDelegate {
+            id: presetItem
+            width: ListView.view.width
+
+            property bool available: model.isAvailable || false
+            property bool isCurrent: model.isCurrent || false
+
+            // Always show presets, but disable unavailable ones
+            enabled: available
+            opacity: available ? 1.0 : 0.6
+
+            contentItem: RowLayout {
+                spacing: Kirigami.Units.smallSpacing
+
+                ColumnLayout {
+                    Layout.fillWidth: true
+                    spacing: 2
+
+                    PlasmaComponents.Label {
+                        Layout.fillWidth: true
+                        text: model.name || i18nc("@label", "Unnamed Preset")
+                        font.bold: true
+                        elide: Text.ElideRight
+                    }
+
+                    PlasmaComponents.Label {
+                        Layout.fillWidth: true
+                        text: model.description || i18nc("@info", "%1 display(s)", model.outputCount || 0)
+                        opacity: 0.6
+                        font.pointSize: Kirigami.Theme.smallFont.pointSize
+                        elide: Text.ElideRight
+                    }
+                }
+
+                // Preview icon button
+                PlasmaComponents.ToolButton {
+                    id: previewButton
+                    icon.name: "monitor"
+                    Layout.preferredWidth: Kirigami.Units.iconSizes.smallMedium
+                    Layout.preferredHeight: Kirigami.Units.iconSizes.smallMedium
+
+                    MouseArea {
+                        anchors.fill: parent
+                        hoverEnabled: true
+
+                        onEntered: {
+                            sharedHoverTimer.targetPopup = previewPopup
+                            sharedHoverTimer.start()
+                        }
+
+                        onExited: {
+                            sharedHoverTimer.stop()
+                            if (!previewPopup.hovered) {
+                                previewPopup.close()
+                            }
+                        }
+                    }
+
+                }
+
+                PlasmaComponents.Button {
+                    id: currentButton
+                    Layout.preferredWidth: Kirigami.Units.gridUnit * 5
+                    text: i18nc("@info:status Current preset is active", "Current")
+                    icon.name: "checkmark"
+                    enabled: false
+                    visible: presetItem.isCurrent
+
+                    PlasmaComponents.ToolTip {
+                        text: i18nc("@info:tooltip", "This display preset is currently active")
+                    }
+                }
+
+                PlasmaComponents.Button {
+                    id: applyButton
+                    Layout.preferredWidth: Kirigami.Units.gridUnit * 5
+                    text: i18nc("@action:button Apply display preset", "Apply")
+                    icon.name: "dialog-ok-apply"
+                    visible: !presetItem.isCurrent
+                    enabled: presetItem.available
+                    onClicked: {
+                        if (loadPresetFunc) {
+                            loadPresetFunc(model.presetId)
+                        }
+                    }
+
+                    PlasmaComponents.ToolTip {
+                        text: presetItem.available
+                            ? i18nc("@info:tooltip", "Apply this display preset")
+                            : i18nc("@info:tooltip", "Some monitors required by this preset are not connected")
+                    }
+                }
+
+            }
+
+            // Preview popup - moved outside the RowLayout to avoid positioning issues
+            QQC2.Popup {
+                id: previewPopup
+                parent: QQC2.Overlay.overlay  // Use overlay for unrestricted positioning
+                clip: false  // Disable clipping to allow extension beyond bounds
+                modal: false  // Not modal so it doesn't block interaction
+
+                property bool hovered: false
+
+                // Dynamic sizing with reasonable bounds
+                readonly property real maxPopupWidth: Kirigami.Units.gridUnit * 30
+                readonly property real maxPopupHeight: Kirigami.Units.gridUnit * 20
+                readonly property real minPopupWidth: Kirigami.Units.gridUnit * 12
+                readonly property real minPopupHeight: Kirigami.Units.gridUnit * 8
+
+                // Calculate size based on layout aspect ratio
+                readonly property real contentAspectRatio: {
+                    if (!presetViewContent.outputs || presetViewContent.outputs.length === 0) {
+                        return 16/9; // Default aspect ratio
+                    }
+
+                    var bounds = presetViewContent.bounds;
+                    var layoutWidth = bounds.maxX - bounds.minX;
+                    var layoutHeight = bounds.maxY - bounds.minY;
+
+                    if (layoutWidth <= 0 || layoutHeight <= 0) {
+                        return 16/9;
+                    }
+
+                    return layoutWidth / layoutHeight;
+                }
+
+                // Fixed width for consistent positioning, dynamic height based on aspect ratio
+                width: Kirigami.Units.gridUnit * 30
+
+                height: {
+                    var idealHeight = width / contentAspectRatio;
+                    return Math.max(minPopupHeight, Math.min(maxPopupHeight, idealHeight));
+                }
+
+                closePolicy: QQC2.Popup.NoAutoClose
+
+                onAboutToShow: {
+                    hoverArea.forceActiveFocus()
+                    // Set initial position when popup opens
+                    if (previewButton && parent) {
+                        var globalPos = previewButton.mapToItem(parent, 0, 0);
+                        x = globalPos.x - width - Kirigami.Units.largeSpacing;
+                        y = globalPos.y - height/2;
+                    }
+                }
+
+                background: Rectangle {
+                    color: Kirigami.Theme.backgroundColor
+                    border.color: Kirigami.Theme.textColor
+                    border.width: 1
+                    radius: 4
+                    clip: false  // Also disable clipping on background
+
+                    MouseArea {
+                        id: hoverArea
+                        anchors.fill: parent
+                        hoverEnabled: true
+
+                        onEntered: {
+                            previewPopup.hovered = true
+                        }
+
+                        onExited: {
+                            previewPopup.hovered = false
+                            previewPopup.close()
+                        }
+                    }
+                }
+
+                contentItem: PresetView {
+                    id: presetViewContent
+                    outputs: model.configuration ? model.configuration.outputs : []
+                    presetAvailable: presetItem.available
+                    kcm: null // We don't have KCM in plasmoid, but PresetView should handle null
+                    clip: false  // Disable clipping on content too
+                }
+            }
+        }
+
+        PlasmaComponents.Label {
+            anchors.centerIn: parent
+            visible: listView.count === 0
+            text: i18nc("@info", "No presets available for current displays")
+            opacity: 0.6
+        }
+    }
+}
\ No newline at end of file
diff --git a/plasmoid/PresetOutput.qml b/plasmoid/PresetOutput.qml
new file mode 100644
index 00000000..34e333cc
--- /dev/null
+++ b/plasmoid/PresetOutput.qml
@@ -0,0 +1,179 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+    Based on Output.qml by Roman Gilg, Dan Vratil, and Kai Uwe Broulik
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+import QtQuick 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Controls 2.15 as QQC2
+import org.kde.kirigami 2.20 as Kirigami
+import org.kde.private.kcm.kscreen 1.0 as KScreen
+
+Item {
+    id: presetOutput
+
+    property var outputData: null
+    property var kcm: null
+    property real scaleFactor: 1.0
+    property real xOffset: 0
+    property real yOffset: 0
+    property var bounds: ({ minX: 0, minY: 0, maxX: 1920, maxY: 1080 })
+
+    readonly property var pos: outputData?.pos || { x: 0, y: 0 }
+    readonly property var mode: outputData?.mode || { width: 1920, height: 1080 }
+    readonly property real scale: outputData?.scale || 1
+    readonly property real monitorWidth: mode.width / scale
+    readonly property real monitorHeight: mode.height / scale
+    readonly property bool outputAvailable: !kcm || kcm.isOutputCurrentlyConnected(outputData?.id || "")
+
+    visible: outputData?.enabled !== false
+    x: ((pos.x || 0) - bounds.minX) * scaleFactor + xOffset
+    y: ((pos.y || 0) - bounds.minY) * scaleFactor + yOffset
+    width: monitorWidth * scaleFactor
+    height: monitorHeight * scaleFactor
+    opacity: outputAvailable ? 1.0 : 0.4
+
+    Rectangle {
+        id: outline
+        anchors.centerIn: parent
+        width: parent.width
+        height: parent.height
+        radius: 2
+        color: outputAvailable ? Kirigami.Theme.backgroundColor : Kirigami.Theme.disabledTextColor
+        border.color: outputAvailable ? Kirigami.Theme.textColor : Kirigami.Theme.disabledTextColor
+        border.width: 2
+
+        // Simple bottom bar as orientation indicator
+        Rectangle {
+            anchors {
+                left: parent.left
+                right: parent.right
+                bottom: parent.bottom
+                margins: 1
+            }
+            height: 2
+            color: parent.border.color
+        }
+
+        // Priority number in top-right corner
+        Rectangle {
+            anchors {
+                top: parent.top
+                right: parent.right
+                margins: 2
+            }
+            width: priorityText.width + 4
+            height: priorityText.height + 2
+            radius: 2
+            color: Kirigami.Theme.highlightColor
+            visible: parent.width > 30 && parent.height > 20
+
+            Text {
+                id: priorityText
+                anchors.centerIn: parent
+                text: presetOutput.outputData?.priority || "1"
+                color: Kirigami.Theme.highlightedTextColor
+                font.pixelSize: Math.max(6, Math.min(10, parent.parent.parent.height / 8))
+                font.bold: true
+            }
+        }
+
+        // Monitor info text - responsive to scaled size
+        Column {
+            anchors.centerIn: parent
+            spacing: Math.max(1, parent.height / 15)
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                width: parent.parent.width - 4
+                text: {
+                    // Use displayName if available (generated by Utils::outputName())
+                    var displayName = presetOutput.outputData?.displayName;
+                    if (displayName) {
+                        return displayName;
+                    }
+
+                    var name = "";
+                    var vendor = presetOutput.outputData?.vendor || "";
+                    var model = presetOutput.outputData?.model || "";
+
+                    if (vendor) {
+                        name = vendor + " ";
+                    }
+                    if (model) {
+                        name += model + " ";
+                    }
+
+                    if (name.trim()) {
+                        return name.trim();
+                    }
+
+                    return i18nc("@label default monitor name", "Monitor");
+                }
+                color: Kirigami.Theme.textColor
+                font.pixelSize: Math.max(6, Math.min(12, parent.parent.height / 5))
+                font.bold: false
+                horizontalAlignment: Text.AlignHCenter
+                wrapMode: Text.Wrap
+                maximumLineCount: 2
+                visible: parent.parent.height > 15
+            }
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: {
+                    // Use Utils::sizeToString() for consistent formatting
+                    var res = presetOutput.kcm ?
+                        presetOutput.kcm.formatResolution(mode.width || 1920, mode.height || 1080) :
+                        (mode.width || 1920) + "×" + (mode.height || 1080);
+                    var refresh = Math.round(mode.refreshRate || 60) + "Hz";
+                    var extras = [];
+
+                    // Get monitor capabilities
+                    var capabilities = presetOutput.outputData?.capabilities || 0;
+
+                    // Check for HDR - monitor must support it and have it enabled
+                    var supportsHdr = (capabilities & KScreen.Output.Capability.HighDynamicRange) !== 0;
+                    if (presetOutput.outputData?.hdr && supportsHdr) {
+                        extras.push("<b>" + i18nc("@label HDR indicator", "HDR") + "</b>");
+                    }
+
+                    // Check for EDR policy - 1 means Always enabled, and monitor must support EDR
+                    var edrPolicy = presetOutput.outputData?.edr_policy;
+                    var supportsEdr = (capabilities & KScreen.Output.Capability.ExtendedDynamicRange) !== 0;
+                    if (edrPolicy === 1 && supportsEdr) {
+                        extras.push("<b>" + i18nc("@label EDR indicator", "EDR") + "</b>");
+                    }
+
+                    var result = res + " " + refresh;
+                    if (extras.length > 0) {
+                        result += " " + extras.join(" ");
+                    }
+
+                    return result;
+                }
+                color: Kirigami.Theme.textColor
+                font.pixelSize: Math.max(5, Math.min(10, parent.parent.height / 6))
+                opacity: 0.8
+                horizontalAlignment: Text.AlignHCenter
+                elide: Text.ElideRight
+                textFormat: Text.RichText
+                visible: parent.parent.height > 20
+            }
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: {
+                    var scale = presetOutput.outputData?.scale || 1;
+                    return i18nc("@info monitor scale factor", "Scale: %1%", Math.round(scale * 100));
+                }
+                color: Kirigami.Theme.textColor
+                font.pixelSize: Math.max(5, Math.min(9, parent.parent.height / 7))
+                opacity: 0.7
+                horizontalAlignment: Text.AlignHCenter
+                visible: parent.parent.height > 25
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plasmoid/PresetView.qml b/plasmoid/PresetView.qml
new file mode 100644
index 00000000..4f051a92
--- /dev/null
+++ b/plasmoid/PresetView.qml
@@ -0,0 +1,96 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+    Based on ScreenView.qml by Roman Gilg
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+import QtQuick 2.15
+import QtQuick.Layouts 1.15
+import QtQuick.Controls 2.15 as QQC2
+import org.kde.kirigami 2.20 as Kirigami
+
+Item {
+    id: presetView
+
+    property var outputs: []
+    property bool presetAvailable: true
+    property var kcm: null
+
+
+    // Calculate bounds for real positioning
+    readonly property var bounds: {
+        if (!outputs || outputs.length === 0) {
+            return { minX: 0, minY: 0, maxX: 1920, maxY: 1080 };
+        }
+
+        var minX = 999999, minY = 999999, maxX = -999999, maxY = -999999;
+
+        for (var i = 0; i < outputs.length; i++) {
+            var output = outputs[i];
+            if (!output.enabled) continue;
+
+            var pos = output.pos || { x: 0, y: 0 };
+            var mode = output.mode || { width: 1920, height: 1080 };
+            var scale = output.scale || 1;
+
+            var w = mode.width / scale;
+            var h = mode.height / scale;
+            var x = pos.x || 0;
+            var y = pos.y || 0;
+
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x + w);
+            maxY = Math.max(maxY, y + h);
+        }
+
+        if (minX === 999999) {
+            return { minX: 0, minY: 0, maxX: 1920, maxY: 1080 };
+        }
+
+        return { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
+    }
+
+    readonly property real layoutWidth: bounds.maxX - bounds.minX
+    readonly property real layoutHeight: bounds.maxY - bounds.minY
+
+    // Scale to fit container - similar to ScreenView's relativeFactor
+    readonly property real scaleFactor: {
+        if (layoutWidth <= 0 || layoutHeight <= 0 || width <= 0 || height <= 0) {
+            return 0.1;
+        }
+        var margin = 15; // Increased margin for better spacing
+        var scaleX = (width - margin * 2) / layoutWidth;
+        var scaleY = (height - margin * 2) / layoutHeight;
+        var finalScale = Math.min(scaleX, scaleY);
+
+        return finalScale;
+    }
+
+    readonly property real xOffset: (width - layoutWidth * scaleFactor) / 2 // Center horizontally
+    readonly property real yOffset: (height - layoutHeight * scaleFactor) / 2
+
+    // Real positioned monitors using Repeater with PresetOutput delegate
+    Repeater {
+        model: outputs
+
+        delegate: PresetOutput {
+            outputData: modelData
+            kcm: presetView.kcm
+            scaleFactor: presetView.scaleFactor
+            xOffset: presetView.xOffset
+            yOffset: presetView.yOffset
+            bounds: presetView.bounds
+        }
+    }
+
+    // Placeholder when no outputs - similar to ScreenView pattern
+    Kirigami.Icon {
+        anchors.centerIn: parent
+        width: Math.min(parent.width * 0.5, Kirigami.Units.iconSizes.medium)
+        height: width
+        source: "computer"
+        opacity: 0.3
+        visible: !outputs || outputs.length === 0
+    }
+}
\ No newline at end of file
diff --git a/plasmoid/kscreenapplet.cpp b/plasmoid/kscreenapplet.cpp
index b0864093..63bdf94b 100644
--- a/plasmoid/kscreenapplet.cpp
+++ b/plasmoid/kscreenapplet.cpp
@@ -6,6 +6,7 @@
 */
 
 #include "kscreenapplet.h"
+#include "kscreen_applet_debug.h"
 
 #include <QMetaEnum>
 #include <QQmlEngine> // for qmlRegisterType
@@ -17,12 +18,23 @@
 #include <KScreen/Output>
 #include <KScreen/SetConfigOperation>
 
+#include <QDBusArgument>
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+
 #include <algorithm>
 
 K_PLUGIN_CLASS_WITH_JSON(KScreenApplet, "metadata.json")
 
 KScreenApplet::KScreenApplet(QObject *parent, const KPluginMetaData &data, const QVariantList &args)
     : Plasma::Applet(parent, data, args)
+    , m_presetsInterface(new QDBusInterface(QStringLiteral("org.kde.kscreen.presets"),
+                                            QStringLiteral("/"),
+                                            QStringLiteral("org.kde.kscreen.presets"),
+                                            QDBusConnection::sessionBus(),
+                                            this))
+    , m_presetModel(new PresetModel(m_presetsInterface, this))
 {
     qmlRegisterUncreatableMetaObject(KScreen::OsdAction::staticMetaObject,
                                      "org.kde.private.kscreen",
@@ -30,6 +42,9 @@ KScreenApplet::KScreenApplet(QObject *parent, const KPluginMetaData &data, const
                                      0,
                                      "OsdAction",
                                      QStringLiteral("Can't create OsdAction"));
+
+    // Register KScreen::Output for PresetOutput.qml compatibility
+    qmlRegisterType<KScreen::Output>("org.kde.private.kcm.kscreen", 1, 0, "Output");
 }
 
 KScreenApplet::~KScreenApplet() = default;
@@ -54,11 +69,25 @@ int KScreenApplet::connectedOutputCount() const
     return m_connectedOutputCount;
 }
 
+QAbstractItemModel *KScreenApplet::presetModel() const
+{
+    return m_presetModel;
+}
+
 void KScreenApplet::applyLayoutPreset(KScreen::OsdAction::Action action)
 {
     KScreen::OsdAction::applyAction(m_screenConfiguration, action);
 }
 
+void KScreenApplet::loadPreset(const QString &presetId)
+{
+    if (!m_presetsInterface || !m_presetsInterface->isValid()) {
+        return;
+    }
+
+    m_presetsInterface->asyncCall(QStringLiteral("applyPreset"), presetId);
+}
+
 void KScreenApplet::checkOutputs()
 {
     if (!m_screenConfiguration) {
@@ -75,6 +104,11 @@ void KScreenApplet::checkOutputs()
     if (m_connectedOutputCount != oldConnectedOutputCount) {
         emit connectedOutputCountChanged();
     }
+
+    // Always update preset status when outputs change
+    if (m_presetModel) {
+        m_presetModel->refreshPresets();
+    }
 }
 
 QVariant KScreenApplet::availableActions()
@@ -91,6 +125,209 @@ QVariant KScreenApplet::availableActions()
     return QVariant::fromValue(ret);
 }
 
+// PresetModel implementation
+PresetModel::PresetModel(QDBusInterface *presetsInterface, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_presetsInterface(presetsInterface)
+{
+    // Connect to D-Bus signal for preset availability changes
+    if (m_presetsInterface && m_presetsInterface->isValid()) {
+        qCDebug(KSCREEN_APPLET) << "PresetModel: D-Bus interface is valid, connecting signals and loading presets";
+        QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.kscreen.presets"),
+                                              QStringLiteral("/"),
+                                              QStringLiteral("org.kde.kscreen.presets"),
+                                              QStringLiteral("presetsChanged"),
+                                              this,
+                                              SLOT(onPresetAvailabilityChanged()));
+
+        // Load initial presets
+        refreshPresets();
+    } else {
+        qCWarning(KSCREEN_APPLET) << "PresetModel: D-Bus interface is NOT valid!"
+                                  << "Interface exists:" << (m_presetsInterface != nullptr)
+                                  << "Is valid:" << (m_presetsInterface ? m_presetsInterface->isValid() : false)
+                                  << "Service:" << (m_presetsInterface ? m_presetsInterface->service() : "null")
+                                  << "Last error:" << (m_presetsInterface ? m_presetsInterface->lastError().message() : "no interface");
+    }
+}
+
+int PresetModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+    return m_presets.count();
+}
+
+QVariant PresetModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_presets.count()) {
+        return QVariant();
+    }
+
+    const QVariant &presetVariant = m_presets.at(index.row());
+    const QVariantMap preset = presetVariant.toMap();
+
+    switch (role) {
+    case IdRole:
+        return preset[QStringLiteral("presetId")];
+    case NameRole:
+        return preset[QStringLiteral("name")];
+    case DescriptionRole:
+        return preset[QStringLiteral("description")];
+    case LastUsedRole:
+        return preset[QStringLiteral("lastUsed")];
+    case OutputCountRole:
+        return preset[QStringLiteral("outputCount")];
+    case ShortcutRole:
+        return preset[QStringLiteral("shortcut")];
+    case ConfigurationRole: {
+        QVariant configVar = preset[QStringLiteral("configuration")];
+        if (configVar.toMap().contains(QStringLiteral("outputs"))) {
+            QVariantList outputs = configVar.toMap()[QStringLiteral("outputs")].toList();
+            qCDebug(KSCREEN_APPLET) << "PresetModel: Returning configuration with" << outputs.count() << "outputs for preset"
+                                    << preset[QStringLiteral("name")].toString();
+        }
+        return configVar;
+    }
+    case IsCurrentRole:
+        return preset[QStringLiteral("isCurrent")];
+    case IsAvailableRole:
+        return preset[QStringLiteral("isAvailable")];
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> PresetModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[IdRole] = "presetId";
+    roles[NameRole] = "name";
+    roles[DescriptionRole] = "description";
+    roles[LastUsedRole] = "lastUsed";
+    roles[OutputCountRole] = "outputCount";
+    roles[ShortcutRole] = "shortcut";
+    roles[ConfigurationRole] = "configuration";
+    roles[IsCurrentRole] = "isCurrent";
+    roles[IsAvailableRole] = "isAvailable";
+    return roles;
+}
+
+void PresetModel::refreshPresets()
+{
+    if (!m_presetsInterface || !m_presetsInterface->isValid()) {
+        qCWarning(KSCREEN_APPLET) << "PresetModel::refreshPresets() - interface not valid";
+        return;
+    }
+
+    QDBusReply<QVariantList> reply = m_presetsInterface->call(QStringLiteral("getPresets"));
+    if (reply.isValid()) {
+        QVariantList presets;
+        const QVariantList &rawPresets = reply.value();
+
+        // Process each preset
+        for (const QVariant &rawPreset : rawPresets) {
+            QVariantMap preset;
+
+            if (rawPreset.canConvert<QDBusArgument>()) {
+                preset = deserializePresetData(rawPreset.value<QDBusArgument>());
+            } else if (rawPreset.canConvert<QVariantMap>()) {
+                preset = rawPreset.toMap();
+            }
+
+            // getPresets already includes isAvailable and isCurrent
+
+            presets.append(preset);
+        }
+
+        beginResetModel();
+        m_presets = presets;
+        endResetModel();
+    } else {
+        qCWarning(KSCREEN_APPLET) << "PresetModel::refreshPresets() - D-Bus call failed:" << reply.error().message();
+    }
+}
+
+void PresetModel::onPresetAvailabilityChanged()
+{
+    qCDebug(KSCREEN_APPLET) << "PresetModel: Received presetsChanged signal, refreshing presets";
+    refreshPresets();
+}
+
+QVariantMap PresetModel::deserializePresetData(const QDBusArgument &arg) const
+{
+    QVariantMap preset;
+    arg >> preset;
+
+    // Deserialize nested configuration if it's QDBusArgument
+    if (preset.contains(QStringLiteral("configuration"))) {
+        QVariant configVar = preset[QStringLiteral("configuration")];
+        if (configVar.canConvert<QDBusArgument>()) {
+            QDBusArgument configArg = configVar.value<QDBusArgument>();
+            QVariantMap configMap;
+            configArg >> configMap;
+
+            // Deserialize outputs array if it's QDBusArgument
+            if (configMap.contains(QStringLiteral("outputs"))) {
+                QVariant outputsVar = configMap[QStringLiteral("outputs")];
+                if (outputsVar.canConvert<QDBusArgument>()) {
+                    QVariantList outputsList = deserializeOutputsList(outputsVar.value<QDBusArgument>());
+                    configMap[QStringLiteral("outputs")] = outputsList;
+                    qCDebug(KSCREEN_APPLET) << "PresetModel: Deserialized" << outputsList.count() << "outputs from QDBusArgument";
+                } else if (outputsVar.canConvert<QVariantList>()) {
+                    configMap[QStringLiteral("outputs")] = outputsVar.toList();
+                    qCDebug(KSCREEN_APPLET) << "PresetModel: Got" << outputsVar.toList().count() << "outputs as QVariantList";
+                }
+            } else {
+                qCDebug(KSCREEN_APPLET) << "PresetModel: Configuration does not contain outputs";
+            }
+
+            preset[QStringLiteral("configuration")] = configMap;
+        }
+    }
+
+    return preset;
+}
+
+QVariantList PresetModel::deserializeOutputsList(const QDBusArgument &outputsArg) const
+{
+    QVariantList outputsList;
+    outputsArg >> outputsList;
+
+    QVariantList deserializedOutputs;
+    for (const QVariant &outputVar : outputsList) {
+        if (outputVar.canConvert<QDBusArgument>()) {
+            QVariantMap outputMap = deserializeOutputData(outputVar.value<QDBusArgument>());
+            deserializedOutputs.append(outputMap);
+        } else {
+            deserializedOutputs.append(outputVar);
+        }
+    }
+
+    return deserializedOutputs;
+}
+
+QVariantMap PresetModel::deserializeOutputData(const QDBusArgument &outputArg) const
+{
+    QVariantMap outputMap;
+    outputArg >> outputMap;
+
+    // Deserialize nested fields that might be QDBusArgument
+    QStringList nestedFields = {"pos", "mode", "logicalSize"};
+    for (const QString &field : nestedFields) {
+        if (outputMap.contains(field)) {
+            QVariant fieldVar = outputMap[field];
+            if (fieldVar.canConvert<QDBusArgument>()) {
+                QDBusArgument fieldArg = fieldVar.value<QDBusArgument>();
+                QVariantMap fieldMap;
+                fieldArg >> fieldMap;
+                outputMap[field] = fieldMap;
+            }
+        }
+    }
+
+    return outputMap;
+}
+
 #include "kscreenapplet.moc"
 
 #include "moc_kscreenapplet.cpp"
diff --git a/plasmoid/kscreenapplet.h b/plasmoid/kscreenapplet.h
index 990ad0d3..315a7a86 100644
--- a/plasmoid/kscreenapplet.h
+++ b/plasmoid/kscreenapplet.h
@@ -13,6 +13,48 @@
 
 #include "common/osdaction.h"
 
+#include <QAbstractListModel>
+
+class QDBusInterface;
+class QDBusArgument;
+
+class PresetModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+    enum PresetRoles {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        DescriptionRole,
+        LastUsedRole,
+        OutputCountRole,
+        ShortcutRole,
+        ConfigurationRole,
+        IsCurrentRole,
+        IsAvailableRole
+    };
+
+    explicit PresetModel(QDBusInterface *presetsInterface, QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE void refreshPresets();
+
+private Q_SLOTS:
+    void onPresetAvailabilityChanged();
+
+private:
+    QVariantMap deserializePresetData(const QDBusArgument &arg) const;
+    QVariantList deserializeOutputsList(const QDBusArgument &outputsArg) const;
+    QVariantMap deserializeOutputData(const QDBusArgument &outputArg) const;
+
+    QDBusInterface *m_presetsInterface;
+    QVariantList m_presets;
+};
+
 class KScreenApplet : public Plasma::Applet
 {
     Q_OBJECT
@@ -22,6 +64,7 @@ class KScreenApplet : public Plasma::Applet
      */
     Q_PROPERTY(int connectedOutputCount READ connectedOutputCount NOTIFY connectedOutputCountChanged FINAL)
     Q_PROPERTY(QVariant availableActions READ availableActions CONSTANT STORED false FINAL)
+    Q_PROPERTY(QAbstractItemModel *presetModel READ presetModel CONSTANT FINAL)
 
 public:
     explicit KScreenApplet(QObject *parent, const KPluginMetaData &data, const QVariantList &args);
@@ -30,8 +73,10 @@ public:
     void init() override;
 
     int connectedOutputCount() const;
+    QAbstractItemModel *presetModel() const;
 
     Q_INVOKABLE void applyLayoutPreset(KScreen::OsdAction::Action action);
+    Q_INVOKABLE void loadPreset(const QString &presetId);
 
     static QVariant availableActions();
 
@@ -43,4 +88,6 @@ private:
 
     KScreen::ConfigPtr m_screenConfiguration;
     int m_connectedOutputCount = 0;
+    QDBusInterface *m_presetsInterface = nullptr;
+    PresetModel *m_presetModel = nullptr;
 };
diff --git a/plasmoid/main.qml b/plasmoid/main.qml
index 832b0824..9017028c 100644
--- a/plasmoid/main.qml
+++ b/plasmoid/main.qml
@@ -14,6 +14,7 @@ import org.kde.config as KConfig
 import org.kde.kcmutils as KCMUtils
 import org.kde.kirigami as Kirigami
 import org.kde.plasma.core as PlasmaCore
+import org.kde.plasma.components as PlasmaComponents
 import org.kde.plasma.plasma5support as P5Support
 import org.kde.plasma.plasmoid
 import org.kde.private.kscreen as KScreen
@@ -78,6 +79,7 @@ PlasmoidItem {
         spacing: 0
         Layout.preferredWidth: Kirigami.Units.gridUnit * 15
 
+
         ScreenLayoutSelection {
             Layout.leftMargin: Kirigami.Units.smallSpacing
             Layout.fillWidth: true
@@ -90,6 +92,14 @@ PlasmoidItem {
             Layout.leftMargin: Kirigami.Units.smallSpacing
         }
 
+        PresetList {
+            Layout.fillWidth: true
+            Layout.topMargin: Kirigami.Units.smallSpacing * 2
+            Layout.leftMargin: Kirigami.Units.smallSpacing
+            model: Plasmoid.presetModel
+            loadPresetFunc: Plasmoid.loadPreset
+        }
+
         // compact the layout
         Item {
             Layout.fillHeight: true
diff --git a/presets/CMakeLists.txt b/presets/CMakeLists.txt
new file mode 100644
index 00000000..9ff9b28c
--- /dev/null
+++ b/presets/CMakeLists.txt
@@ -0,0 +1,38 @@
+add_executable(kscreen_presets_service
+    main.cpp
+    presetsservice.cpp
+    presetsservice.h
+)
+
+ecm_qt_declare_logging_category(kscreen_presets_service
+    HEADER
+        presets_debug.h
+    IDENTIFIER
+        KSCREEN_PRESETS
+    CATEGORY_NAME
+        kscreen.presets
+     DESCRIPTION "kscreen presets service (kscreen)" EXPORT KSCREEN
+)
+
+target_link_libraries(kscreen_presets_service PRIVATE
+    kscreen_common
+    Qt::Core
+    Qt::Gui
+    Qt::DBus
+    KF6::Screen
+    KF6::I18n
+    KF6::GlobalAccel
+)
+
+install(TARGETS kscreen_presets_service DESTINATION ${KDE_INSTALL_LIBEXECDIR})
+
+ecm_generate_dbus_service_file(
+    NAME org.kde.kscreen.presets
+    EXECUTABLE ${KDE_INSTALL_FULL_LIBEXECDIR}/kscreen_presets_service
+    DESTINATION ${KDE_INSTALL_DBUSSERVICEDIR}
+    SYSTEMD_SERVICE plasma-kscreen-presets.service
+)
+
+ecm_install_configured_files(INPUT plasma-kscreen-presets.service @ONLY
+    DESTINATION ${KDE_INSTALL_SYSTEMDUSERUNITDIR}
+)
\ No newline at end of file
diff --git a/presets/main.cpp b/presets/main.cpp
new file mode 100644
index 00000000..64d624d4
--- /dev/null
+++ b/presets/main.cpp
@@ -0,0 +1,57 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include <QCommandLineParser>
+#include <QDBusConnection>
+#include <QGuiApplication>
+
+#include "presets_debug.h"
+#include "presetsservice.h"
+
+QString parseCommandLineArguments(QGuiApplication &app)
+{
+    QCommandLineParser parser;
+    parser.setApplicationDescription("KScreen Display Presets Service");
+    parser.addHelpOption();
+    parser.addVersionOption();
+
+    QCommandLineOption presetsFileOption(QStringList() << "p" << "presets-file", "Use custom presets file path instead of default location", "file");
+    parser.addOption(presetsFileOption);
+
+    parser.process(app);
+
+    const QString customFilePath = parser.isSet(presetsFileOption) ? parser.value(presetsFileOption) : QString();
+
+    if (!customFilePath.isEmpty()) {
+        qCDebug(KSCREEN_PRESETS) << "Custom presets file specified:" << customFilePath;
+    }
+
+    return customFilePath;
+}
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication app(argc, argv);
+    app.setApplicationName("kscreen_presets_service");
+    app.setApplicationVersion("1.0");
+
+    const QString customFilePath = parseCommandLineArguments(app);
+
+    if (!QDBusConnection::sessionBus().isConnected()) {
+        qCCritical(KSCREEN_PRESETS) << "Cannot connect to the D-Bus session bus."
+                                    << "To start it, run: eval `dbus-launch --auto-syntax`";
+        return 1;
+    }
+
+    PresetsService service(nullptr, customFilePath);
+
+    if (!service.init()) {
+        qCCritical(KSCREEN_PRESETS) << "Failed to initialize PresetsService";
+        return 1;
+    }
+
+    return app.exec();
+}
\ No newline at end of file
diff --git a/presets/org.kde.kscreen.presets.xml b/presets/org.kde.kscreen.presets.xml
new file mode 100644
index 00000000..3eba0b47
--- /dev/null
+++ b/presets/org.kde.kscreen.presets.xml
@@ -0,0 +1,19 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.kde.kscreen.presets">
+    <!-- Preset management methods -->
+    <method name="applyPreset">
+      <arg name="presetId" type="s" direction="in" />
+    </method>
+    <method name="getPresets">
+      <arg name="presets" type="av" direction="out" />
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantList"/>
+    </method>
+
+    <!-- Preset change notification signal -->
+    <signal name="presetsChanged">
+      <arg name="changedPresets" type="av" direction="out" />
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantList"/>
+    </signal>
+  </interface>
+</node>
\ No newline at end of file
diff --git a/presets/plasma-kscreen-presets.service b/presets/plasma-kscreen-presets.service
new file mode 100644
index 00000000..01e29f43
--- /dev/null
+++ b/presets/plasma-kscreen-presets.service
@@ -0,0 +1,8 @@
+[Unit]
+Description=KScreen Presets Service
+PartOf=graphical-session.target
+
+[Service]
+Type=dbus
+BusName=org.kde.kscreen.presets
+ExecStart=@KDE_INSTALL_FULL_LIBEXECDIR@/kscreen_presets_service
\ No newline at end of file
diff --git a/presets/presetsservice.cpp b/presets/presetsservice.cpp
new file mode 100644
index 00000000..41dfb0aa
--- /dev/null
+++ b/presets/presetsservice.cpp
@@ -0,0 +1,461 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "presetsservice.h"
+#include "presets_debug.h"
+
+#include <KScreen/Config>
+#include <KScreen/ConfigMonitor>
+#include <KScreen/GetConfigOperation>
+#include <KScreen/Mode>
+#include <KScreen/Output>
+#include <KScreen/SetConfigOperation>
+
+#include <KGlobalAccel>
+
+#include <QDBusConnection>
+#include <QDBusMetaType>
+#include <QTimer>
+#include <stdexcept>
+
+PresetsService::PresetsService(QObject *parent, const QString &customPresetsFile)
+    : QObject(parent)
+{
+    m_presets = new Presets(this, customPresetsFile);
+
+    m_configMonitor = KScreen::ConfigMonitor::instance();
+    connect(m_configMonitor, &KScreen::ConfigMonitor::configurationChanged, this, &PresetsService::configChanged);
+
+    // Timer to debounce rapid config changes
+    m_configUpdateTimer = new QTimer(this);
+    m_configUpdateTimer->setSingleShot(true);
+    m_configUpdateTimer->setInterval(500); // 500ms delay
+    connect(m_configUpdateTimer, &QTimer::timeout, this, &PresetsService::updatePresetScreenConfiguration);
+
+    // Initialize shortcuts and emit D-Bus signal when presets change
+    connect(m_presets, &Presets::presetsChanged, this, &PresetsService::initShortcuts);
+    connect(m_presets, &Presets::presetsChanged, this, &PresetsService::onPresetsModelChanged);
+}
+
+PresetsService::~PresetsService() = default;
+
+bool PresetsService::init()
+{
+    qCDebug(KSCREEN_PRESETS) << "Initializing PresetsService";
+
+    // Register D-Bus meta types for complex data types
+    qDBusRegisterMetaType<QVariantList>();
+    qDBusRegisterMetaType<QVariantMap>();
+
+    if (!QDBusConnection::sessionBus().registerObject(QStringLiteral("/"),
+                                                      this,
+                                                      QDBusConnection::ExportScriptableSlots | QDBusConnection::ExportScriptableSignals)) {
+        qCCritical(KSCREEN_PRESETS) << "Failed to register D-Bus object";
+        return false;
+    }
+
+    if (!QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kscreen.presets"))) {
+        qCCritical(KSCREEN_PRESETS) << "Failed to register D-Bus service";
+        return false;
+    }
+
+    // Initialize cache with current presets
+    m_previousPresets = getPresets();
+
+    // Get initial screen configuration
+    updatePresetScreenConfiguration();
+
+    qCDebug(KSCREEN_PRESETS) << "PresetsService initialized successfully";
+    return true;
+}
+
+void PresetsService::configChanged()
+{
+    // Restart timer on each config change to debounce rapid changes
+    m_configUpdateTimer->start();
+}
+
+void PresetsService::updatePresetScreenConfiguration()
+{
+    qCDebug(KSCREEN_PRESETS) << "Updating preset screen configuration";
+
+    // Use KCM-style GetConfigOperation approach
+    connect(new KScreen::GetConfigOperation(), &KScreen::GetConfigOperation::finished, this, &PresetsService::configReady);
+}
+
+void PresetsService::configReady(KScreen::ConfigOperation *op)
+{
+    qCDebug(KSCREEN_PRESETS) << "Config operation finished";
+
+    if (op->hasError()) {
+        qCWarning(KSCREEN_PRESETS) << "GetConfigOperation failed:" << op->errorString();
+        op->deleteLater();
+        return;
+    }
+
+    auto config = qobject_cast<KScreen::GetConfigOperation *>(op)->config();
+    qCDebug(KSCREEN_PRESETS) << "GetConfigOperation successful, outputs count:" << (config ? config->outputs().count() : 0);
+
+    if (config) {
+        // Add config to monitor like KDED and KCM do
+        KScreen::ConfigMonitor::instance()->addConfig(config);
+
+        m_presets->setScreenConfiguration(config);
+        emitPresetsChanged();
+        qCDebug(KSCREEN_PRESETS) << "Screen configuration updated successfully";
+    } else {
+        qCWarning(KSCREEN_PRESETS) << "Failed to update screen configuration - missing config";
+    }
+
+    op->deleteLater();
+}
+
+void PresetsService::applyPreset(const QString &presetId)
+{
+    qCDebug(KSCREEN_PRESETS) << "Applying preset:" << presetId;
+
+    if (!m_presets->isPresetAvailable(presetId)) {
+        const QString error = QStringLiteral("Preset not available: %1").arg(presetId);
+        qCWarning(KSCREEN_PRESETS) << error;
+        Q_EMIT errorOccurred(error);
+        return;
+    }
+
+    // Find preset data
+    QVariantMap presetData;
+    for (int i = 0; i < m_presets->rowCount(); ++i) {
+        const QModelIndex idx = m_presets->index(i, 0);
+        if (m_presets->data(idx, Presets::IdRole).toString() == presetId) {
+            presetData = m_presets->data(idx, Presets::ConfigurationRole).toMap();
+            break;
+        }
+    }
+
+    if (presetData.isEmpty()) {
+        const QString error = QStringLiteral("Preset data not found: %1").arg(presetId);
+        qCWarning(KSCREEN_PRESETS) << error;
+        Q_EMIT errorOccurred(error);
+        return;
+    }
+
+    // Get current config and apply preset
+    auto *getConfigOp = new KScreen::GetConfigOperation();
+    connect(getConfigOp, &KScreen::GetConfigOperation::finished, this, [this, presetId, presetData](KScreen::ConfigOperation *op) {
+        if (op->hasError()) {
+            const QString error = QStringLiteral("Failed to get current config: %1").arg(op->errorString());
+            qCWarning(KSCREEN_PRESETS) << error;
+            Q_EMIT errorOccurred(error);
+            op->deleteLater();
+            return;
+        }
+
+        auto config = qobject_cast<KScreen::GetConfigOperation *>(op)->config();
+        if (!config) {
+            const QString error = QStringLiteral("Invalid config received");
+            qCWarning(KSCREEN_PRESETS) << error;
+            Q_EMIT errorOccurred(error);
+            op->deleteLater();
+            return;
+        }
+
+        // Apply preset configuration
+        const QVariantList outputsList = presetData.value(QStringLiteral("outputs")).toList();
+        const QHash<QString, QVariantMap> presetOutputsMap = buildPresetOutputsMap(outputsList);
+
+        const auto outputs = config->outputs();
+        for (const auto &output : outputs) {
+            if (presetOutputsMap.contains(output->name())) {
+                applyPresetToOutput(output, presetOutputsMap[output->name()], config);
+            }
+        }
+
+        // Apply the configuration
+        auto *setConfigOp = new KScreen::SetConfigOperation(config);
+        connect(setConfigOp, &KScreen::SetConfigOperation::finished, this, [this, presetId](KScreen::ConfigOperation *setOp) {
+            if (setOp->hasError()) {
+                const QString error = QStringLiteral("Failed to apply preset: %1").arg(setOp->errorString());
+                qCWarning(KSCREEN_PRESETS) << error;
+                Q_EMIT errorOccurred(error);
+            } else {
+                // Update last used timestamp
+                m_presets->updateLastUsed(presetId);
+                qCDebug(KSCREEN_PRESETS) << "Preset applied successfully:" << presetId;
+                Q_EMIT presetApplied(presetId);
+            }
+            setOp->deleteLater();
+        });
+
+        op->deleteLater();
+    });
+}
+
+QVariantList PresetsService::getPresets()
+{
+    QVariantList presets;
+
+    for (int i = 0; i < m_presets->rowCount(); ++i) {
+        const QModelIndex index = m_presets->index(i, 0);
+        QVariantMap preset;
+
+        const QString presetId = m_presets->data(index, Presets::IdRole).toString();
+        preset[QStringLiteral("presetId")] = presetId;
+        preset[QStringLiteral("name")] = m_presets->data(index, Presets::NameRole).toString();
+        preset[QStringLiteral("description")] = m_presets->data(index, Presets::DescriptionRole).toString();
+
+        // Convert QDateTime to string for D-Bus serialization
+        QDateTime lastUsed = m_presets->data(index, Presets::LastUsedRole).toDateTime();
+        preset[QStringLiteral("lastUsed")] = lastUsed.toString(Qt::ISODate);
+
+        preset[QStringLiteral("outputCount")] = m_presets->data(index, Presets::OutputCountRole).toInt();
+
+        // Add configuration data
+        preset[QStringLiteral("configuration")] = m_presets->data(index, Presets::ConfigurationRole);
+
+        // Convert QKeySequence to string for D-Bus serialization
+        QKeySequence shortcut = m_presets->data(index, Presets::ShortcutRole).value<QKeySequence>();
+        preset[QStringLiteral("shortcut")] = shortcut.toString();
+
+        // Check if preset is available and current
+        preset[QStringLiteral("isAvailable")] = m_presets->isPresetAvailable(presetId);
+        preset[QStringLiteral("isCurrent")] = m_presets->isPresetCurrent(presetId);
+
+        presets.append(preset);
+    }
+
+    return presets;
+}
+
+void PresetsService::emitPresetsChanged(const QStringList &changedPresetIds)
+{
+    QVariantList changedPresets;
+
+    if (changedPresetIds.isEmpty()) {
+        // If no specific presets specified, emit all presets with current status
+        for (int i = 0; i < m_presets->rowCount(); ++i) {
+            const QModelIndex index = m_presets->index(i, 0);
+            const QString presetId = m_presets->data(index, Presets::IdRole).toString();
+            changedPresets.append(getPresetInfo(presetId));
+        }
+    } else {
+        // Emit only specified presets
+        for (const QString &presetId : changedPresetIds) {
+            changedPresets.append(getPresetInfo(presetId));
+        }
+    }
+
+    Q_EMIT presetsChanged(changedPresets);
+}
+
+QVariantMap PresetsService::getPresetInfo(const QString &presetId) const
+{
+    QVariantMap preset;
+
+    // Find preset in model
+    for (int i = 0; i < m_presets->rowCount(); ++i) {
+        const QModelIndex index = m_presets->index(i, 0);
+        if (m_presets->data(index, Presets::IdRole).toString() == presetId) {
+            preset[QStringLiteral("presetId")] = presetId;
+            preset[QStringLiteral("name")] = m_presets->data(index, Presets::NameRole).toString();
+            preset[QStringLiteral("description")] = m_presets->data(index, Presets::DescriptionRole).toString();
+
+            // Convert QDateTime to string for D-Bus serialization
+            QDateTime lastUsed = m_presets->data(index, Presets::LastUsedRole).toDateTime();
+            preset[QStringLiteral("lastUsed")] = lastUsed.toString(Qt::ISODate);
+
+            preset[QStringLiteral("outputCount")] = m_presets->data(index, Presets::OutputCountRole).toInt();
+
+            // Add configuration data
+            preset[QStringLiteral("configuration")] = m_presets->data(index, Presets::ConfigurationRole);
+
+            // Convert QKeySequence to string for D-Bus serialization
+            QKeySequence shortcut = m_presets->data(index, Presets::ShortcutRole).value<QKeySequence>();
+            preset[QStringLiteral("shortcut")] = shortcut.toString();
+
+            // Check current status
+            preset[QStringLiteral("isAvailable")] = m_presets->isPresetAvailable(presetId);
+            preset[QStringLiteral("isCurrent")] = m_presets->isPresetCurrent(presetId);
+            preset[QStringLiteral("deleted")] = false;
+            return preset;
+        }
+    }
+
+    // Preset not found - mark as deleted
+    preset[QStringLiteral("presetId")] = presetId;
+    preset[QStringLiteral("deleted")] = true;
+    return preset;
+}
+
+void PresetsService::initShortcuts()
+{
+    // Clear existing shortcuts
+    for (auto action : m_shortcutActions) {
+        KGlobalAccel::self()->removeAllShortcuts(action);
+        action->deleteLater();
+    }
+    m_shortcutActions.clear();
+
+    // Register shortcuts for all presets
+    for (int i = 0; i < m_presets->rowCount(); ++i) {
+        const QModelIndex idx = m_presets->index(i, 0);
+        const QString presetId = m_presets->data(idx, Presets::IdRole).toString();
+        const QKeySequence shortcut = m_presets->data(idx, Presets::ShortcutRole).value<QKeySequence>();
+
+        if (!shortcut.isEmpty()) {
+            registerShortcut(presetId, shortcut);
+        }
+    }
+}
+
+QHash<QString, QVariantMap> PresetsService::buildPresetOutputsMap(const QVariantList &presetOutputsList) const
+{
+    QHash<QString, QVariantMap> outputsMap;
+    for (const auto &outputVariant : presetOutputsList) {
+        const QVariantMap outputMap = outputVariant.toMap();
+        const QString outputName = outputMap.value(QStringLiteral("name")).toString();
+        if (!outputName.isEmpty()) {
+            outputsMap[outputName] = outputMap;
+        }
+    }
+    return outputsMap;
+}
+
+void PresetsService::applyPresetToOutput(const KScreen::OutputPtr &output, const QVariantMap &presetOutputMap, KScreen::ConfigPtr config) const
+{
+    Q_UNUSED(config)
+
+    // Apply basic output settings
+    const bool enabled = presetOutputMap.value(QStringLiteral("enabled"), false).toBool();
+    output->setEnabled(enabled);
+
+    if (!enabled) {
+        return;
+    }
+
+    // Apply position
+    const QVariantMap posMap = presetOutputMap.value(QStringLiteral("pos")).toMap();
+    const QPoint position(posMap.value(QStringLiteral("x"), 0).toInt(), posMap.value(QStringLiteral("y"), 0).toInt());
+    output->setPos(position);
+
+    // Apply mode
+    const QString modeId = presetOutputMap.value(QStringLiteral("currentModeId")).toString();
+    if (!modeId.isEmpty() && output->modes().contains(modeId)) {
+        output->setCurrentModeId(modeId);
+    }
+
+    // Apply rotation
+    const int rotation = presetOutputMap.value(QStringLiteral("rotation"), 1).toInt();
+    output->setRotation(static_cast<KScreen::Output::Rotation>(rotation));
+
+    // Apply scale
+    const qreal scale = presetOutputMap.value(QStringLiteral("scale"), 1.0).toReal();
+    output->setScale(scale);
+
+    // Apply primary status
+    const bool primary = presetOutputMap.value(QStringLiteral("primary"), false).toBool();
+    output->setPrimary(primary);
+}
+
+void PresetsService::registerShortcut(const QString &presetId, const QKeySequence &shortcut)
+{
+    if (shortcut.isEmpty()) {
+        return;
+    }
+
+    auto action = new QAction(this);
+    action->setObjectName(QStringLiteral("preset_%1").arg(presetId));
+    action->setText(QStringLiteral("Apply Display Preset"));
+
+    connect(action, &QAction::triggered, this, [this, presetId]() {
+        applyPreset(presetId);
+    });
+
+    KGlobalAccel::self()->setShortcut(action, {shortcut});
+    m_shortcutActions[presetId] = action;
+}
+
+void PresetsService::unregisterShortcut(const QString &presetId)
+{
+    auto it = m_shortcutActions.find(presetId);
+    if (it != m_shortcutActions.end()) {
+        KGlobalAccel::self()->removeAllShortcuts(it.value());
+        it.value()->deleteLater();
+        m_shortcutActions.erase(it);
+    }
+}
+
+void PresetsService::onPresetsModelChanged()
+{
+    const QStringList changedPresetIds = detectChangedPresets();
+    if (!changedPresetIds.isEmpty()) {
+        emitPresetsChanged(changedPresetIds);
+    }
+
+    // Update cached presets for next comparison
+    m_previousPresets = getPresets();
+}
+
+QStringList PresetsService::detectChangedPresets() const
+{
+    QStringList changedIds;
+
+    // We need to cast away const to call getPresets() - this is safe for read-only access
+    const QVariantList currentPresets = const_cast<PresetsService *>(this)->getPresets();
+
+    // Convert lists to maps for easier comparison
+    QHash<QString, QVariantMap> previousMap;
+    for (const auto &preset : m_previousPresets) {
+        const QVariantMap presetMap = preset.toMap();
+        previousMap[presetMap.value(QStringLiteral("presetId")).toString()] = presetMap;
+    }
+
+    QHash<QString, QVariantMap> currentMap;
+    for (const auto &preset : currentPresets) {
+        const QVariantMap presetMap = preset.toMap();
+        currentMap[presetMap.value(QStringLiteral("presetId")).toString()] = presetMap;
+    }
+
+    // Check for new or modified presets
+    for (auto it = currentMap.constBegin(); it != currentMap.constEnd(); ++it) {
+        const QString presetId = it.key();
+        const QVariantMap currentPreset = it.value();
+
+        if (!previousMap.contains(presetId)) {
+            // New preset
+            changedIds.append(presetId);
+        } else {
+            // Check if preset was modified
+            const QVariantMap previousPreset = previousMap.value(presetId);
+
+            // Compare key fields (excluding isAvailable/isCurrent which change based on screen config)
+            const QStringList fieldsToCompare = {QStringLiteral("name"), QStringLiteral("description"), QStringLiteral("shortcut"), QStringLiteral("lastUsed")};
+
+            bool isModified = false;
+            for (const QString &field : fieldsToCompare) {
+                if (currentPreset.value(field) != previousPreset.value(field)) {
+                    isModified = true;
+                    break;
+                }
+            }
+
+            if (isModified) {
+                changedIds.append(presetId);
+            }
+        }
+    }
+
+    // Check for deleted presets
+    for (auto it = previousMap.constBegin(); it != previousMap.constEnd(); ++it) {
+        const QString presetId = it.key();
+        if (!currentMap.contains(presetId)) {
+            // Preset was deleted - emit it with deleted flag
+            changedIds.append(presetId);
+        }
+    }
+
+    return changedIds;
+}
+
+#include "moc_presetsservice.cpp"
\ No newline at end of file
diff --git a/presets/presetsservice.h b/presets/presetsservice.h
new file mode 100644
index 00000000..a5bf051c
--- /dev/null
+++ b/presets/presetsservice.h
@@ -0,0 +1,62 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#pragma once
+
+#include "common/presets.h"
+
+#include <QAction>
+#include <QObject>
+#include <QTimer>
+
+namespace KScreen
+{
+class ConfigMonitor;
+class ConfigOperation;
+}
+
+class PresetsService : public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.kde.kscreen.presets")
+
+public:
+    explicit PresetsService(QObject *parent = nullptr, const QString &customPresetsFile = QString());
+    ~PresetsService() override;
+
+    bool init();
+
+public Q_SLOTS:
+    Q_SCRIPTABLE void applyPreset(const QString &presetId);
+    Q_SCRIPTABLE QVariantList getPresets();
+
+Q_SIGNALS:
+    Q_SCRIPTABLE void presetsChanged(const QVariantList &changedPresets);
+    void presetApplied(const QString &presetId);
+    void errorOccurred(const QString &error);
+
+private Q_SLOTS:
+    void configChanged();
+    void configReady(KScreen::ConfigOperation *op);
+    void initShortcuts();
+    void onPresetsModelChanged();
+
+private:
+    void updatePresetScreenConfiguration();
+    void emitPresetsChanged(const QStringList &changedPresetIds = {});
+    QVariantMap getPresetInfo(const QString &presetId) const;
+    QHash<QString, QVariantMap> buildPresetOutputsMap(const QVariantList &presetOutputsList) const;
+    void applyPresetToOutput(const KScreen::OutputPtr &output, const QVariantMap &presetOutputMap, KScreen::ConfigPtr config) const;
+    void registerShortcut(const QString &presetId, const QKeySequence &shortcut);
+    void unregisterShortcut(const QString &presetId);
+    QStringList detectChangedPresets() const;
+
+    Presets *m_presets = nullptr;
+    KScreen::ConfigMonitor *m_configMonitor = nullptr;
+    QTimer *m_configUpdateTimer = nullptr;
+    QHash<QString, QAction *> m_shortcutActions;
+    QVariantList m_previousPresets; // Cache of previous presets for change detection
+};
\ No newline at end of file
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e8bd8241..01b87a48 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1 +1,2 @@
 add_subdirectory(kded)
+add_subdirectory(presets)
diff --git a/tests/presets/CMakeLists.txt b/tests/presets/CMakeLists.txt
new file mode 100644
index 00000000..5ca7004e
--- /dev/null
+++ b/tests/presets/CMakeLists.txt
@@ -0,0 +1,28 @@
+include_directories(${CMAKE_BINARY_DIR})
+
+add_definitions(-DCMAKE_BINARY_DIR="${CMAKE_BINARY_DIR}")
+
+# Test for presets service functionality
+add_executable(testpresets testpresets.cpp)
+target_compile_definitions(testpresets PRIVATE "-DTEST_DATA=\"${CMAKE_CURRENT_SOURCE_DIR}/\"")
+target_link_libraries(testpresets
+    Qt6::Test
+    Qt6::Core
+    Qt6::DBus
+)
+add_test(NAME kscreen-presets-testpresets COMMAND testpresets)
+ecm_mark_as_test(testpresets)
+
+# Simple test
+add_executable(testsimple testsimple.cpp)
+target_compile_definitions(testsimple PRIVATE
+    "-DTEST_DATA=\"${CMAKE_CURRENT_SOURCE_DIR}/\""
+    "-DCMAKE_BINARY_DIR=\"${CMAKE_BINARY_DIR}\""
+)
+target_link_libraries(testsimple
+    Qt6::Test
+    Qt6::Core
+    Qt6::DBus
+)
+add_test(NAME kscreen-presets-testsimple COMMAND testsimple)
+ecm_mark_as_test(testsimple)
\ No newline at end of file
diff --git a/tests/presets/testpresets.cpp b/tests/presets/testpresets.cpp
new file mode 100644
index 00000000..b1f24567
--- /dev/null
+++ b/tests/presets/testpresets.cpp
@@ -0,0 +1,507 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include <QDBusArgument>
+#include <QDBusConnection>
+#include <QDBusConnectionInterface>
+#include <QDBusInterface>
+#include <QDBusMetaType>
+#include <QDBusReply>
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QObject>
+#include <QProcess>
+#include <QSignalSpy>
+#include <QTemporaryDir>
+#include <QtTest>
+
+class TestPresets : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+    // Test preset file changes detection
+    void testPresetModification();
+    void testPresetAddition();
+    void testPresetRemoval();
+    void testMultipleChanges();
+    void testSignalOnlyChangedPresets();
+
+private:
+    void createTestPresetsFile();
+    void modifyPreset(const QString &presetId, const QString &field, const QJsonValue &value);
+    void addPreset(const QJsonObject &preset);
+    void removePreset(const QString &presetId);
+    QJsonObject readPresetsFile();
+    void writePresetsFile(const QJsonObject &data);
+    bool waitForService();
+    QVariantMap extractPresetFromDBus(const QVariant &preset);
+
+    QString m_presetsFilePath;
+    QTemporaryDir m_tempDir;
+    QJsonObject m_originalPresets;
+    QProcess *m_serviceProcess = nullptr;
+    QDBusInterface *m_dbusInterface = nullptr;
+};
+
+void TestPresets::initTestCase()
+{
+    // Register D-Bus meta types for complex data types
+    qDBusRegisterMetaType<QVariantList>();
+    qDBusRegisterMetaType<QVariantMap>();
+
+    // Setup temporary directory for test data
+    QVERIFY(m_tempDir.isValid());
+
+    // Override XDG_CONFIG_HOME to use our temp directory
+    qputenv("XDG_CONFIG_HOME", m_tempDir.path().toLocal8Bit() + "/.config");
+
+    // Create directory structure
+    const QString configDir = m_tempDir.path() + "/.config/kscreen";
+    QDir().mkpath(configDir);
+    m_presetsFilePath = configDir + "/presets.json";
+
+    // Create initial test presets file
+    createTestPresetsFile();
+}
+
+void TestPresets::cleanupTestCase()
+{
+    if (m_serviceProcess) {
+        m_serviceProcess->terminate();
+        if (!m_serviceProcess->waitForFinished(5000)) {
+            m_serviceProcess->kill();
+        }
+        delete m_serviceProcess;
+    }
+
+    if (m_dbusInterface) {
+        delete m_dbusInterface;
+    }
+}
+
+void TestPresets::init()
+{
+    // Register D-Bus types for proper signal handling
+    qDBusRegisterMetaType<QVariantList>();
+    qDBusRegisterMetaType<QVariantMap>();
+
+    // Reset to original presets for each test
+    writePresetsFile(m_originalPresets);
+
+    // Start the presets service
+    m_serviceProcess = new QProcess(this);
+
+    // Set environment for the service
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+    env.insert("XDG_CONFIG_HOME", m_tempDir.path() + "/.config");
+    m_serviceProcess->setProcessEnvironment(env);
+
+    // Start the service with custom presets file
+    const QString servicePath = QStringLiteral(CMAKE_BINARY_DIR "/bin/kscreen_presets_service");
+    const QStringList arguments{"-p", m_presetsFilePath};
+    m_serviceProcess->start(servicePath, arguments);
+
+    // Wait for service to be ready
+    QVERIFY(waitForService());
+
+    // Create DBus interface
+    m_dbusInterface = new QDBusInterface(QStringLiteral("org.kde.kscreen.presets"),
+                                         QStringLiteral("/"),
+                                         QStringLiteral("org.kde.kscreen.presets"),
+                                         QDBusConnection::sessionBus(),
+                                         this);
+}
+
+void TestPresets::cleanup()
+{
+    if (m_serviceProcess) {
+        m_serviceProcess->terminate();
+        if (!m_serviceProcess->waitForFinished(5000)) {
+            m_serviceProcess->kill();
+        }
+        delete m_serviceProcess;
+        m_serviceProcess = nullptr;
+    }
+
+    if (m_dbusInterface) {
+        delete m_dbusInterface;
+        m_dbusInterface = nullptr;
+    }
+
+    // Wait a bit for service to fully terminate
+    QTest::qWait(100);
+}
+
+void TestPresets::createTestPresetsFile()
+{
+    QJsonObject root;
+    root["version"] = 1;
+
+    QJsonArray presetsArray;
+
+    // Test preset 1
+    QJsonObject preset1;
+    preset1["id"] = "test-preset-1";
+    preset1["name"] = "Test Preset 1";
+    preset1["description"] = "Original description";
+    preset1["created"] = "2025-09-17T10:00:00";
+    preset1["lastUsed"] = "2025-09-17T10:00:00";
+    preset1["shortcut"] = "Meta+1";
+
+    QJsonObject config1;
+    config1["features"] = 255;
+    QJsonArray outputs1;
+    QJsonObject output1;
+    output1["id"] = "test-output-1";
+    output1["name"] = "HDMI-1";
+    output1["enabled"] = true;
+    output1["pos"] = QJsonObject{{"x", 0}, {"y", 0}};
+    output1["currentModeId"] = "1";
+    outputs1.append(output1);
+    config1["outputs"] = outputs1;
+    preset1["configuration"] = config1;
+
+    QJsonArray outputIds1;
+    outputIds1.append("test-output-1");
+    preset1["outputIds"] = outputIds1;
+
+    presetsArray.append(preset1);
+
+    // Test preset 2
+    QJsonObject preset2;
+    preset2["id"] = "test-preset-2";
+    preset2["name"] = "Test Preset 2";
+    preset2["description"] = "";
+    preset2["created"] = "2025-09-17T11:00:00";
+    preset2["lastUsed"] = "2025-09-17T11:00:00";
+    preset2["shortcut"] = "";
+
+    QJsonObject config2 = config1;
+    preset2["configuration"] = config2;
+    preset2["outputIds"] = outputIds1;
+
+    presetsArray.append(preset2);
+
+    root["presets"] = presetsArray;
+
+    m_originalPresets = root;
+    writePresetsFile(root);
+}
+
+void TestPresets::writePresetsFile(const QJsonObject &data)
+{
+    QFile file(m_presetsFilePath);
+    QVERIFY(file.open(QIODevice::WriteOnly));
+
+    QJsonDocument doc(data);
+    file.write(doc.toJson());
+    file.close();
+}
+
+QJsonObject TestPresets::readPresetsFile()
+{
+    QFile file(m_presetsFilePath);
+    if (!file.open(QIODevice::ReadOnly)) {
+        return QJsonObject();
+    }
+
+    QJsonParseError error;
+    QJsonDocument doc = QJsonDocument::fromJson(file.readAll(), &error);
+    if (error.error != QJsonParseError::NoError) {
+        return QJsonObject();
+    }
+
+    return doc.object();
+}
+
+void TestPresets::modifyPreset(const QString &presetId, const QString &field, const QJsonValue &value)
+{
+    QJsonObject presets = readPresetsFile();
+    QJsonArray presetsArray = presets["presets"].toArray();
+
+    for (int i = 0; i < presetsArray.size(); ++i) {
+        QJsonObject preset = presetsArray[i].toObject();
+        if (preset["id"].toString() == presetId) {
+            preset[field] = value;
+            presetsArray[i] = preset;
+            break;
+        }
+    }
+
+    presets["presets"] = presetsArray;
+    writePresetsFile(presets);
+}
+
+void TestPresets::addPreset(const QJsonObject &preset)
+{
+    QJsonObject presets = readPresetsFile();
+    QJsonArray presetsArray = presets["presets"].toArray();
+    presetsArray.append(preset);
+    presets["presets"] = presetsArray;
+    writePresetsFile(presets);
+}
+
+void TestPresets::removePreset(const QString &presetId)
+{
+    QJsonObject presets = readPresetsFile();
+    QJsonArray presetsArray = presets["presets"].toArray();
+    QJsonArray newArray;
+
+    for (int i = 0; i < presetsArray.size(); ++i) {
+        QJsonObject preset = presetsArray[i].toObject();
+        if (preset["id"].toString() != presetId) {
+            newArray.append(preset);
+        }
+    }
+
+    presets["presets"] = newArray;
+    writePresetsFile(presets);
+}
+
+bool TestPresets::waitForService()
+{
+    // Wait for service to start
+    if (!m_serviceProcess->waitForStarted(5000)) {
+        return false;
+    }
+
+    // Wait for D-Bus registration
+    for (int i = 0; i < 50; ++i) { // 5 seconds total
+        if (QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.kscreen.presets"))) {
+            return true;
+        }
+        QTest::qWait(100);
+    }
+
+    return false;
+}
+
+QVariantMap TestPresets::extractPresetFromDBus(const QVariant &preset)
+{
+    QVariantMap presetMap;
+    if (preset.canConvert<QVariantMap>()) {
+        presetMap = preset.toMap();
+    } else if (preset.canConvert<QDBusArgument>()) {
+        const QDBusArgument dbusArg = preset.value<QDBusArgument>();
+        dbusArg >> presetMap;
+    }
+    return presetMap;
+}
+
+void TestPresets::testPresetModification()
+{
+    QVERIFY(m_dbusInterface);
+    QVERIFY(m_dbusInterface->isValid());
+
+    // Setup signal spy for presetsChanged signal
+    QSignalSpy spy(m_dbusInterface, SIGNAL(presetsChanged(QVariantList)));
+    QVERIFY(spy.isValid());
+
+    // Wait a bit to ensure service is fully ready
+    QTest::qWait(500);
+
+    // Modify a preset
+    modifyPreset("test-preset-1", "description", "Modified description");
+
+    // Wait for signal
+    QVERIFY(spy.wait(5000));
+
+    // Check that signal was emitted with only the changed preset
+    QCOMPARE(spy.count(), 1);
+    const QVariantList args = spy.takeFirst();
+    QCOMPARE(args.size(), 1);
+
+    const QVariantList changedPresets = args[0].toList();
+
+    // With our improved logic, should contain only the changed preset
+    QCOMPARE(changedPresets.size(), 1);
+
+    const QVariantMap changedPreset = extractPresetFromDBus(changedPresets[0]);
+    QVERIFY(changedPreset.contains("presetId"));
+    QCOMPARE(changedPreset["presetId"].toString(), QString("test-preset-1"));
+    QVERIFY(changedPreset.contains("description"));
+    QCOMPARE(changedPreset["description"].toString(), QString("Modified description"));
+}
+
+void TestPresets::testPresetAddition()
+{
+    QVERIFY(m_dbusInterface);
+    QVERIFY(m_dbusInterface->isValid());
+
+    QSignalSpy spy(m_dbusInterface, SIGNAL(presetsChanged(QVariantList)));
+
+    // Add new preset
+    QJsonObject newPreset;
+    newPreset["id"] = "test-preset-new";
+    newPreset["name"] = "New Test Preset";
+    newPreset["description"] = "Newly added preset";
+    newPreset["created"] = "2025-09-17T12:00:00";
+    newPreset["lastUsed"] = "2025-09-17T12:00:00";
+    newPreset["shortcut"] = "Meta+N";
+
+    QJsonObject config;
+    config["features"] = 255;
+    QJsonArray outputs;
+    QJsonObject output;
+    output["id"] = "test-output-new";
+    output["name"] = "HDMI-2";
+    output["enabled"] = true;
+    output["pos"] = QJsonObject{{"x", 0}, {"y", 0}};
+    output["currentModeId"] = "1";
+    outputs.append(output);
+    config["outputs"] = outputs;
+    newPreset["configuration"] = config;
+
+    QJsonArray outputIds;
+    outputIds.append("test-output-new");
+    newPreset["outputIds"] = outputIds;
+
+    addPreset(newPreset);
+
+    // Wait for signal
+    QVERIFY(spy.wait(3000));
+
+    // Check signal contains only the new preset
+    QCOMPARE(spy.count(), 1);
+    const QVariantList args = spy.takeFirst();
+    const QVariantList changedPresets = args[0].toList();
+
+    QCOMPARE(changedPresets.size(), 1);
+
+    const QVariantMap addedPreset = extractPresetFromDBus(changedPresets[0]);
+    QCOMPARE(addedPreset["presetId"].toString(), QString("test-preset-new"));
+    QCOMPARE(addedPreset["name"].toString(), QString("New Test Preset"));
+}
+
+void TestPresets::testPresetRemoval()
+{
+    QVERIFY(m_dbusInterface);
+    QVERIFY(m_dbusInterface->isValid());
+
+    QSignalSpy spy(m_dbusInterface, SIGNAL(presetsChanged(QVariantList)));
+
+    // Remove a preset
+    removePreset("test-preset-1");
+
+    // Wait for signal
+    QVERIFY(spy.wait(3000));
+
+    // Check signal contains the removed preset with deleted flag
+    QCOMPARE(spy.count(), 1);
+    const QVariantList args = spy.takeFirst();
+    const QVariantList changedPresets = args[0].toList();
+
+    QCOMPARE(changedPresets.size(), 1);
+
+    const QVariantMap deletedPreset = extractPresetFromDBus(changedPresets[0]);
+    QCOMPARE(deletedPreset["presetId"].toString(), QString("test-preset-1"));
+    QCOMPARE(deletedPreset["deleted"].toBool(), true);
+}
+
+void TestPresets::testMultipleChanges()
+{
+    QVERIFY(m_dbusInterface);
+    QVERIFY(m_dbusInterface->isValid());
+
+    QSignalSpy spy(m_dbusInterface, SIGNAL(presetsChanged(QVariantList)));
+
+    // Make multiple changes in one file write
+    QJsonObject presets = readPresetsFile();
+    QJsonArray presetsArray = presets["presets"].toArray();
+
+    // Modify first preset
+    QJsonObject preset1 = presetsArray[0].toObject();
+    preset1["name"] = "Modified Test Preset 1";
+    presetsArray[0] = preset1;
+
+    // Add new preset
+    QJsonObject newPreset;
+    newPreset["id"] = "test-preset-multi";
+    newPreset["name"] = "Multi Test";
+    newPreset["description"] = "Added during multi-change test";
+    newPreset["created"] = "2025-09-17T13:00:00";
+    newPreset["lastUsed"] = "2025-09-17T13:00:00";
+    newPreset["shortcut"] = "";
+
+    QJsonObject config;
+    config["features"] = 255;
+    QJsonArray outputs;
+    config["outputs"] = outputs;
+    newPreset["configuration"] = config;
+
+    QJsonArray outputIds;
+    newPreset["outputIds"] = outputIds;
+
+    presetsArray.append(newPreset);
+    presets["presets"] = presetsArray;
+
+    writePresetsFile(presets);
+
+    // Wait for signal
+    QVERIFY(spy.wait(3000));
+
+    // Check signal contains both changed presets
+    QCOMPARE(spy.count(), 1);
+    const QVariantList args = spy.takeFirst();
+    const QVariantList changedPresets = args[0].toList();
+
+    QCOMPARE(changedPresets.size(), 2);
+
+    // Verify both presets are in the signal
+    QStringList changedIds;
+    for (const auto &preset : changedPresets) {
+        const QVariantMap presetMap = extractPresetFromDBus(preset);
+        changedIds.append(presetMap["presetId"].toString());
+    }
+
+    QVERIFY(changedIds.contains("test-preset-1"));
+    QVERIFY(changedIds.contains("test-preset-multi"));
+}
+
+void TestPresets::testSignalOnlyChangedPresets()
+{
+    QVERIFY(m_dbusInterface);
+    QVERIFY(m_dbusInterface->isValid());
+
+    // Get initial presets count
+    QDBusReply<QVariantList> reply = m_dbusInterface->call("getPresets");
+    QVERIFY(reply.isValid());
+
+    const int initialCount = reply.value().size();
+    QCOMPARE(initialCount, 2); // We start with 2 test presets
+
+    QSignalSpy spy(m_dbusInterface, SIGNAL(presetsChanged(QVariantList)));
+
+    // Modify only one preset
+    modifyPreset("test-preset-2", "description", "Changed only this one");
+
+    // Wait for signal
+    QVERIFY(spy.wait(3000));
+
+    // Verify signal contains only 1 preset (the changed one), not all presets
+    QCOMPARE(spy.count(), 1);
+    const QVariantList args = spy.takeFirst();
+    const QVariantList changedPresets = args[0].toList();
+
+    // This is the key test - we should get 1 preset, not all 2
+    QCOMPARE(changedPresets.size(), 1);
+
+    const QVariantMap changedPreset = extractPresetFromDBus(changedPresets[0]);
+    QCOMPARE(changedPreset["presetId"].toString(), QString("test-preset-2"));
+    QCOMPARE(changedPreset["description"].toString(), QString("Changed only this one"));
+}
+
+QTEST_GUILESS_MAIN(TestPresets)
+
+#include "testpresets.moc"
\ No newline at end of file
diff --git a/tests/presets/testsimple.cpp b/tests/presets/testsimple.cpp
new file mode 100644
index 00000000..5f542976
--- /dev/null
+++ b/tests/presets/testsimple.cpp
@@ -0,0 +1,121 @@
+/*
+    SPDX-FileCopyrightText: 2025 Jerzy Kołosowski <jerzy@kolosowscy.pl>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include <QDBusConnection>
+#include <QDBusConnectionInterface>
+#include <QDBusInterface>
+#include <QDBusReply>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QObject>
+#include <QProcess>
+#include <QTemporaryDir>
+#include <QtTest>
+
+class TestPresetsSimple : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void testServiceStartup();
+    void testGetPresets();
+};
+
+void TestPresetsSimple::testServiceStartup()
+{
+    // Start service
+    QProcess service;
+
+    // Setup temp dir for config
+    QTemporaryDir tempDir;
+    QVERIFY(tempDir.isValid());
+
+    // Create config dir
+    const QString configDir = tempDir.path() + "/.config/kscreen";
+    QDir().mkpath(configDir);
+    const QString presetsFilePath = configDir + "/presets.json";
+
+    // Create minimal presets file
+    QJsonObject root;
+    root["version"] = 1;
+
+    QJsonArray presetsArray;
+    QJsonObject preset1;
+    preset1["id"] = "test-1";
+    preset1["name"] = "Test";
+    preset1["description"] = "Test preset";
+    preset1["created"] = "2025-09-17T10:00:00";
+    preset1["lastUsed"] = "2025-09-17T10:00:00";
+    preset1["shortcut"] = "";
+
+    QJsonObject config;
+    config["features"] = 255;
+    config["outputs"] = QJsonArray();
+    preset1["configuration"] = config;
+    preset1["outputIds"] = QJsonArray();
+
+    presetsArray.append(preset1);
+    root["presets"] = presetsArray;
+
+    // Write file
+    QFile file(presetsFilePath);
+    QVERIFY(file.open(QIODevice::WriteOnly));
+    QJsonDocument doc(root);
+    file.write(doc.toJson());
+    file.close();
+
+    // Set environment
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+    env.insert("XDG_CONFIG_HOME", tempDir.path() + "/.config");
+    service.setProcessEnvironment(env);
+
+    // Start service with custom presets file
+    const QString servicePath = CMAKE_BINARY_DIR "/bin/kscreen_presets_service";
+    const QStringList arguments{"-p", presetsFilePath};
+    service.start(servicePath, arguments);
+
+    QVERIFY(service.waitForStarted(5000));
+
+    // Wait for D-Bus registration
+    bool registered = false;
+    for (int i = 0; i < 50; ++i) {
+        if (QDBusConnection::sessionBus().interface()->isServiceRegistered("org.kde.kscreen.presets")) {
+            registered = true;
+            break;
+        }
+        QTest::qWait(100);
+    }
+
+    QVERIFY(registered);
+
+    // Create interface
+    QDBusInterface interface("org.kde.kscreen.presets", "/", "org.kde.kscreen.presets", QDBusConnection::sessionBus());
+
+    QVERIFY(interface.isValid());
+
+    // Call getPresets
+    QDBusReply<QVariantList> reply = interface.call("getPresets");
+    QVERIFY(reply.isValid());
+
+    QVariantList presets = reply.value();
+    QCOMPARE(presets.size(), 1);
+
+    // Cleanup
+    service.terminate();
+    QVERIFY(service.waitForFinished(5000));
+}
+
+void TestPresetsSimple::testGetPresets()
+{
+    // This test just verifies we can get presets
+    // The actual change detection is tested in the main test
+    QSKIP("Tested in testServiceStartup");
+}
+
+QTEST_GUILESS_MAIN(TestPresetsSimple)
+
+#include "testsimple.moc"
\ No newline at end of file
-- 
2.51.0