diff --git a/src/screencast.cpp b/src/screencast.cpp
index ca879e4a11518461c99dd9e6586659d2f19c50c8..81a9b095d9389d34d5386197b0f1e1ae22d3396a 100644
--- a/src/screencast.cpp
+++ b/src/screencast.cpp
@@ -152,8 +152,8 @@ uint ScreenCastPortal::Start(const QDBusObjectPath &handle,
             }
         }
         const auto selectedWindows = screenDialog->selectedWindows();
-        for (const QByteArray &winid : selectedWindows) {
-            if (!WaylandIntegration::startStreamingWindow(winid)) {
+        for (const auto &win : selectedWindows) {
+            if (!WaylandIntegration::startStreamingWindow(win)) {
                 return 2;
             }
         }
diff --git a/src/screencasting.cpp b/src/screencasting.cpp
index 77d0241355f6f175b6a10542758950042ef47af1..621446a6076a9460142a0269350e8268219d8fd7 100644
--- a/src/screencasting.cpp
+++ b/src/screencasting.cpp
@@ -104,13 +104,6 @@ ScreencastingStream *Screencasting::createOutputStream(Output *output, CursorMod
     return stream;
 }
 
-ScreencastingStream *Screencasting::createWindowStream(PlasmaWindow *window, CursorMode mode)
-{
-    auto stream = createWindowStream(QString::fromUtf8(window->uuid()), mode);
-    stream->setObjectName(window->appId());
-    return stream;
-}
-
 ScreencastingStream *Screencasting::createWindowStream(const QString &uuid, CursorMode mode)
 {
     auto stream = new ScreencastingStream(this);
diff --git a/src/screencasting.h b/src/screencasting.h
index 62cf9bafe013710872ff7d76d5a3381eb4b2e92f..2a073d5bc1c1072156e62a6c92bce96f90dcd589 100644
--- a/src/screencasting.h
+++ b/src/screencasting.h
@@ -61,7 +61,6 @@ public:
     Q_ENUM(CursorMode);
 
     ScreencastingStream *createOutputStream(KWayland::Client::Output *output, CursorMode mode);
-    ScreencastingStream *createWindowStream(KWayland::Client::PlasmaWindow *window, CursorMode mode);
     ScreencastingStream *createWindowStream(const QString &uuid, CursorMode mode);
 
     void setup(zkde_screencast_unstable_v1 *screencasting);
diff --git a/src/screenchooserdialog.cpp b/src/screenchooserdialog.cpp
index 204b6b1d2cedee559706e07aa78f1c63d6646be8..c6d5fd8251ff8a1590a97ba511071136d2a1fcb1 100644
--- a/src/screenchooserdialog.cpp
+++ b/src/screenchooserdialog.cpp
@@ -38,6 +38,16 @@ public:
             && !idx.data(PlasmaWindowModel::SkipSwitcher).toBool() //
             && idx.data(PlasmaWindowModel::Pid) != QCoreApplication::applicationPid();
     }
+
+    QMap<int, QVariant> itemData(const QModelIndex &index) const override
+    {
+        using KWayland::Client::PlasmaWindowModel;
+        auto ret = QSortFilterProxyModel::itemData(index);
+        for (int i = PlasmaWindowModel::AppId; i <= PlasmaWindowModel::Uuid; ++i) {
+            ret[i] = index.data(i);
+        }
+        return ret;
+    }
 };
 
 ScreenChooserDialog::ScreenChooserDialog(const QString &appName, bool multiple, QDialog *parent, Qt::WindowFlags flags)
@@ -124,14 +134,15 @@ QList<quint32> ScreenChooserDialog::selectedScreens() const
     return m_dialog->screenView->selectedScreens();
 }
 
-QList<QByteArray> ScreenChooserDialog::selectedWindows() const
+QVector<QMap<int, QVariant>> ScreenChooserDialog::selectedWindows() const
 {
     const auto idxs = m_dialog->windowsView->selectionModel()->selectedIndexes();
 
-    QList<QByteArray> ret;
+    QVector<QMap<int, QVariant>> ret;
     ret.reserve(idxs.count());
     for (const auto &idx : idxs) {
-        ret += idx.data(KWayland::Client::PlasmaWindowModel::Uuid).toByteArray();
+        auto m = idx.model();
+        ret += m->itemData(idx);
     }
     return ret;
 }
diff --git a/src/screenchooserdialog.h b/src/screenchooserdialog.h
index 3515e6c1247b0f4c2ca19aea82b819437cb42e19..d2519273923571f00d5079f09bef3107d2d50aea 100644
--- a/src/screenchooserdialog.h
+++ b/src/screenchooserdialog.h
@@ -28,7 +28,7 @@ public:
     void setSourceTypes(ScreenCastPortal::SourceTypes types);
 
     QList<quint32> selectedScreens() const;
-    QList<QByteArray> selectedWindows() const;
+    QVector<QMap<int, QVariant>> selectedWindows() const;
 
 private:
     void selectionChanged(const QItemSelection &selected);
diff --git a/src/waylandintegration.cpp b/src/waylandintegration.cpp
index 5e89faaa03500216c061c7b04c14df9348dedac8..ccc1e2b995d711e71b01ade4cca602ea082f1cfb 100644
--- a/src/waylandintegration.cpp
+++ b/src/waylandintegration.cpp
@@ -28,12 +28,14 @@
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
+#include <KWayland/Client/plasmawindowmodel.h>
 #include <KWayland/Client/registry.h>
 
 // system
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <KStatusNotifierItem>
 #include <KWayland/Client/fakeinput.h>
 
 Q_LOGGING_CATEGORY(XdgDesktopPortalKdeWaylandIntegration, "xdp-kde-wayland-integration")
@@ -76,9 +78,9 @@ bool WaylandIntegration::startStreamingOutput(quint32 outputName, Screencasting:
     return globalWaylandIntegration->startStreamingOutput(outputName, mode);
 }
 
-bool WaylandIntegration::startStreamingWindow(const QByteArray &winid)
+bool WaylandIntegration::startStreamingWindow(const QMap<int, QVariant> &win)
 {
-    return globalWaylandIntegration->startStreamingWindow(winid);
+    return globalWaylandIntegration->startStreamingWindow(win);
 }
 
 void WaylandIntegration::stopAllStreaming()
@@ -234,19 +236,22 @@ void WaylandIntegration::WaylandIntegrationPrivate::startStreamingInput()
     m_streamInput = true;
 }
 
-bool WaylandIntegration::WaylandIntegrationPrivate::startStreamingWindow(const QByteArray &winid)
+bool WaylandIntegration::WaylandIntegrationPrivate::startStreamingWindow(const QMap<int, QVariant> &win)
 {
-    return startStreaming(m_screencasting->createWindowStream(QString::fromUtf8(winid), Screencasting::Hidden), {});
+    auto uuid = win[KWayland::Client::PlasmaWindowModel::Uuid].toString();
+    return startStreaming(m_screencasting->createWindowStream(uuid, Screencasting::Hidden), {}, win);
 }
 
 bool WaylandIntegration::WaylandIntegrationPrivate::startStreamingOutput(quint32 outputName, Screencasting::CursorMode mode)
 {
     auto output = m_outputMap.value(outputName).output();
 
-    return startStreaming(m_screencasting->createOutputStream(output.data(), mode), output);
+    return startStreaming(m_screencasting->createOutputStream(output.data(), mode), output, {});
 }
 
-bool WaylandIntegration::WaylandIntegrationPrivate::startStreaming(ScreencastingStream *stream, QSharedPointer<KWayland::Client::Output> output)
+bool WaylandIntegration::WaylandIntegrationPrivate::startStreaming(ScreencastingStream *stream,
+                                                                   QSharedPointer<KWayland::Client::Output> output,
+                                                                   const QMap<int, QVariant> &win)
 {
     QEventLoop loop;
     bool streamReady = false;
@@ -282,6 +287,24 @@ bool WaylandIntegration::WaylandIntegrationPrivate::startStreaming(Screencasting
             stopStreaming(nodeid);
         });
         streamReady = true;
+
+        auto item = new KStatusNotifierItem(stream);
+        item->setStandardActionsEnabled(false);
+        if (output) {
+            item->setTitle(i18n("Recording screen \"%1\"...", output->model()));
+            item->setIconByName("video-display");
+        } else {
+            auto name = win[Qt::DecorationRole].value<QIcon>().name();
+            item->setIconByName(name.isEmpty() ? "applications-all" : name);
+            item->setTitle(i18n("Recording window \"%1\"...", win[Qt::DisplayRole].toString()));
+        }
+        item->setOverlayIconByName("media-record");
+        item->setToolTip(item->iconName(), item->title(), i18n("Press to cancel"));
+        connect(item, &KStatusNotifierItem::activateRequested, stream, [=] {
+            stopStreaming(nodeid);
+            stream->deleteLater();
+        });
+
         loop.quit();
     });
     QTimer::singleShot(3000, &loop, &QEventLoop::quit);
diff --git a/src/waylandintegration.h b/src/waylandintegration.h
index 684c54d2fad49163f03556cdd290ebe3f030ad4f..87be498c4608d32b4da2dbe371147c7b451fda60 100644
--- a/src/waylandintegration.h
+++ b/src/waylandintegration.h
@@ -110,7 +110,7 @@ bool isStreamingAvailable();
 
 void startStreamingInput();
 bool startStreamingOutput(quint32 outputName, Screencasting::CursorMode mode);
-bool startStreamingWindow(const QByteArray &winid);
+bool startStreamingWindow(const QMap<int, QVariant> &win);
 void stopAllStreaming();
 
 void requestPointerButtonPress(quint32 linuxButton);
diff --git a/src/waylandintegration_p.h b/src/waylandintegration_p.h
index 8bbc2240d7198a358561d4f460a8a37a3040f42f..4bd4f9f43402a2822e5ed509e076a2f083351019 100644
--- a/src/waylandintegration_p.h
+++ b/src/waylandintegration_p.h
@@ -75,9 +75,9 @@ public:
 
     void startStreamingInput();
 
-    bool startStreaming(ScreencastingStream *stream, QSharedPointer<KWayland::Client::Output> output);
+    bool startStreaming(ScreencastingStream *stream, QSharedPointer<KWayland::Client::Output> output, const QMap<int, QVariant> &win);
     bool startStreamingOutput(quint32 outputName, Screencasting::CursorMode mode);
-    bool startStreamingWindow(const QByteArray &winid);
+    bool startStreamingWindow(const QMap<int, QVariant> &win);
     void stopStreaming(uint32_t nodeid);
     void stopAllStreaming();