18 files changed, 1481 insertions, 355 deletions

diff --git a/accounts/gkleen@sif/default.nix b/accounts/gkleen@sif/default.nix
index f2978b6e..92163dca 100644
--- a/accounts/gkleen@sif/default.nix
+++ b/accounts/gkleen@sif/default.nix
@@ -49,7 +49,8 @@ let
     ];
   };
 
-  lockCommand = "${lib.getExe' config.systemd.package "systemctl"} --user start gtklock.service";
+  # lockCommand = "${lib.getExe' config.systemd.package "systemctl"} --user start gtklock.service";
+  lockCommand = "${lib.getExe' cfg.programs.quickshell.package "qs"} ipc call Lockscreen setLocked true";
 
   editor = pkgs.symlinkJoin {
     inherit (cfg.services.emacs.package) name;
@@ -374,7 +375,7 @@ in {
 
       services = {
         wpaperd = {
-          enable = true;
+          enable = false;
           settings.default = {
             path = "~/.wallpapers";
             duration = "15m";
diff --git a/accounts/gkleen@sif/shell/default.nix b/accounts/gkleen@sif/shell/default.nix
index 26c8bd98..84140072 100644
--- a/accounts/gkleen@sif/shell/default.nix
+++ b/accounts/gkleen@sif/shell/default.nix
@@ -7,8 +7,75 @@
       config = {
         src = ./quickshell;
         replacements = {
-          coreutils = toString pkgs.coreutils;
           ignore_workspaces = builtins.toJSON (map ({ name, ... }: name) config.programs.niri.scratchspaces);
+          wallpapers = builtins.toJSON (pkgs.stdenvNoCC.mkDerivation {
+            name = "wallpapers";
+            srcs = [
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/carinanebula3.tif";
+                hash = "sha256-YxZEweDKJfvfrdxb/QFmgJhcZDEJYxotoHrG+RRn1tw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/pillarsofcreation_composite.tif";
+                hash = "sha256-qRiODxR0lZWdxgYXna0fNRFFDErpBJDwOJuQl6sNjRc=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2212a.tif";
+                hash = "sha256-l2fqE/z//C1a0xkvZwsnwPbTSb+WuA11h+SUl3E1dhw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2415a.tif";
+                hash = "sha256-onBy7cPoUpDuzQStbY2E+qmlGgSLXPwFCLX53ukAb4c=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2330a.tif";
+                hash = "sha256-nn0ZtjZIrPcpj3YcLTsrL7XiXvyh3QYgCSmdDMD+3OM=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2426a.tif";
+                hash = "sha256-EDnfPn3GE9jt6XPqiGInP7E2F3Az7d25NqATSWltDv0=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2503a.tif";
+                hash = "sha256-3/RX6RQp8naELcgReHPd5/zhJkoCjnA10w5BEnNo+qI=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2506a.tif";
+                hash = "sha256-aDld0aoY1owRxDVf7Jcyw71TH42M1foYotxn2thyFYw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2514a.tif";
+                hash = "sha256-jTi1G1Ofo5xsF6ggrbtYJHxqLaCQ7edM5B3uORiVQtg=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2425c.tif";
+                hash = "sha256-oaEOexSJHEGj090dJF3ct5HAoR+Y5gRiPrUlxdvnTRo=";
+              })
+            ];
+
+            dontUnpack = true;
+
+            buildInputs = [ pkgs.imagemagick ];
+            buildPhase = ''
+              runHook preBuild
+
+              typeset sources=($srcs)
+
+              mkdir -p $out
+              magick ''${sources[0]} -crop 10000x5625+0+79 +repage -define jpeg:extent=10MB $out/carinanebula3.jpeg
+              magick ''${sources[1]} -crop 6716x3778+329+80 +repage -define jpeg:extent=10MB $out/pillarsofcreation_composite.jpeg
+              magick ''${sources[2]} -crop 10000x5625+0+79 +repage -define jpeg:extent=10MB $out/weic2212a.jpeg
+              magick ''${sources[3]} -crop 7650x4302+1166+389 +repage -define jpeg:extent=10MB $out/weic2415a.jpeg
+              magick ''${sources[4]} -crop 8732x4912+0+434 +repage -define jpeg:extent=10MB $out/weic2330a.jpeg
+              magick ''${sources[5]} -crop 5302x2982+636+0 +repage -define jpeg:extent=10MB $out/weic2426a.jpeg
+              magick ''${sources[6]} -crop 4328x2434+0+906 +repage -define jpeg:extent=10MB $out/weic2503a.jpeg
+              magick ''${sources[7]} -crop 4152x2335+0+666 +repage -define jpeg:extent=10MB $out/weic2506a.jpeg
+              magick ''${sources[8]} -crop 4320x2430+0+0 +repage -define jpeg:extent=10MB $out/weic2514a.jpeg
+              magick ''${sources[9]} -crop 5863x3298+0+477 +repage -define jpeg:extent=10MB $out/weic2425c.jpeg
+
+              runHook postBuild
+            '';
+          });
         };
       };
     };
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt b/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
index aa363c4c..2123ed35 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
@@ -104,6 +104,7 @@ qt6_add_qml_module(customplugin
 
 target_sources(customplugin PRIVATE
     Chrono.cpp Chrono.hpp
+    FileSelector.cpp FileSelector.hpp
 )
 
 target_compile_features(customplugin PUBLIC cxx_std_26)
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
index 929b7be6..22b3469b 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
@@ -42,9 +42,11 @@ void Chrono::update() {
 }
 
 void Chrono::setTime(const std::chrono::time_point<std::chrono::system_clock>& targetTime) {
+  using namespace std::chrono_literals;
+
   auto currentTime = std::chrono::system_clock::now();
   auto offset = std::chrono::duration_cast<std::chrono::milliseconds>(targetTime - currentTime);
-  this->currentTime = abs(offset.count()) < 500 ? targetTime : currentTime;
+  this->currentTime = abs(offset) < 500ms ? targetTime : currentTime;
 
   switch (this->mPrecision) {
   case Chrono::Hours: this->currentTime = std::chrono::time_point_cast<std::chrono::hours>(this->currentTime);
@@ -56,33 +58,26 @@ void Chrono::setTime(const std::chrono::time_point<std::chrono::system_clock>& t
 }
 
 void Chrono::schedule(const std::chrono::time_point<std::chrono::system_clock>& targetTime) {
+  using namespace std::chrono_literals;
+
   auto currentTime = std::chrono::system_clock::now();
   auto offset = std::chrono::duration_cast<std::chrono::milliseconds>(targetTime - currentTime);
-  auto nextTime = abs(offset.count()) < 500 ? targetTime : currentTime;
-
-  {
-    using namespace std::chrono_literals;
+  auto nextTime = abs(offset) < 500ms ? targetTime : currentTime;
 
-    switch (this->mPrecision) {
-    case Chrono::Hours: nextTime = std::chrono::time_point_cast<std::chrono::hours>(nextTime) + 1h;
-    case Chrono::Minutes: nextTime = std::chrono::time_point_cast<std::chrono::minutes>(nextTime) + 1min;
-    case Chrono::Seconds: nextTime = std::chrono::time_point_cast<std::chrono::seconds>(nextTime) + 1s;
-    }
+  switch (this->mPrecision) {
+  case Chrono::Hours: nextTime = std::chrono::time_point_cast<std::chrono::hours>(nextTime) + 1h;
+  case Chrono::Minutes: nextTime = std::chrono::time_point_cast<std::chrono::minutes>(nextTime) + 1min;
+  case Chrono::Seconds: nextTime = std::chrono::time_point_cast<std::chrono::seconds>(nextTime) + 1s;
   }
 
   this->targetTime = nextTime;
-  auto delay = std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime);
-  this->timer.start(delay);
+  this->timer.start(std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime));
 }
 
-QString Chrono::format() const { return this->mFormat; }
-void Chrono::setFormat(QString format) {
-  if (format == this->mFormat) return;
-  this->mFormat = format;
-  emit this->formatChanged();
-  this->update();
+QString Chrono::format(const QString& fmt) const {
+  return QString::fromStdString(std::format(std::runtime_format(fmt.toStdString()), std::chrono::zoned_time(std::chrono::current_zone(), std::chrono::time_point_cast<std::chrono::seconds>(this->currentTime))));
 }
 
-QString Chrono::date() const {
-  return QString::fromStdString(std::format(std::runtime_format(this->mFormat.toStdString()), std::chrono::zoned_time(std::chrono::current_zone(), std::chrono::time_point_cast<std::chrono::seconds>(this->currentTime))));
+QDateTime Chrono::date() const {
+  return QDateTime::fromStdTimePoint(std::chrono::time_point_cast<std::chrono::milliseconds>(this->currentTime));
 }
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
index 788fa88e..04080187 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
@@ -1,17 +1,18 @@
 #pragma once
 
+#include <chrono>
+
+#include <QDateTime>
 #include <QObject>
 #include <QTimer>
 
 #include <qqmlintegration.h>
-#include <chrono>
 
 class Chrono : public QObject {
   Q_OBJECT;
   Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged);
   Q_PROPERTY(Chrono::Precision precision READ precision WRITE setPrecision NOTIFY precisionChanged);
-  Q_PROPERTY(QString format READ format WRITE setFormat NOTIFY formatChanged);
-  Q_PROPERTY(QString date READ date NOTIFY dateChanged);
+  Q_PROPERTY(QDateTime date READ date NOTIFY dateChanged)
   QML_ELEMENT;
 
 public:
@@ -30,15 +31,13 @@ public:
   Chrono::Precision precision() const;
   void setPrecision(Chrono::Precision precision);
 
-  QString format() const;
-  void setFormat (QString format);
+  Q_INVOKABLE QString format(const QString& fmt) const;
 
-  QString date() const;
+  QDateTime date() const;
 
 signals:
   void enabledChanged();
   void precisionChanged();
-  void formatChanged();
   void dateChanged();
 
 private slots:
@@ -47,7 +46,6 @@ private slots:
 private:
   bool mEnabled = true;
   Chrono::Precision mPrecision = Chrono::Seconds;
-  QString mFormat = "{:%c}";
   QTimer timer;
   std::chrono::time_point<std::chrono::system_clock> currentTime, targetTime;
 
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp
new file mode 100644
index 00000000..d7051d2a
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp
@@ -0,0 +1,102 @@
+#include "FileSelector.hpp"
+
+#include <sstream>
+#include <vector>
+#include <random>
+#include <algorithm>
+
+#include <iostream>
+#include <format>
+
+namespace fs = std::filesystem;
+
+FileSelector::FileSelector(QObject* parent): QObject(parent) {
+  QObject::connect(&this->timer, &QTimer::timeout, this, &FileSelector::onTimeout);
+  this->timer.setTimerType(Qt::PreciseTimer);
+}
+
+QString FileSelector::directory() const {
+  return QString::fromStdString(this->mDirectory->string());
+}
+void FileSelector::setDirectory(QString directory) {
+  this->mDirectory = directory.toStdString();
+  if (this->mDirectory && this->mEpoch)
+    this->update();
+  emit this->directoryChanged();
+}
+
+unsigned int FileSelector::epoch() const {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(*this->mEpoch).count();
+}
+void FileSelector::setEpoch(unsigned int epoch) {
+  this->mEpoch = std::chrono::milliseconds{epoch};
+  if (this->mDirectory && this->mEpoch)
+    this->update();
+  emit this->epochChanged();
+}
+
+QString FileSelector::seed() const {
+  return this->mSeed;
+}
+void FileSelector::setSeed(QString seed) {
+  this->mSeed = seed;
+  emit this->seedChanged();
+  if (this->mDirectory && this->mEpoch)
+    emit this->selectedChanged();
+}
+
+QString FileSelector::selected() const {
+  if (!this->mDirectory || !this->mEpoch)
+    return QString();
+
+  std::vector<fs::path> shuffled(this->mFiles.begin(), this->mFiles.end());
+  std::sort(shuffled.begin(), shuffled.end());
+
+  auto currentTime = std::chrono::system_clock::now();
+  uint64_t currentEpoch = currentTime.time_since_epoch() / *this->mEpoch;
+  std::chrono::milliseconds timeInEpoch = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime.time_since_epoch()) % *this->mEpoch;
+
+  std::ostringstream seed;
+  seed << this->mSeed.size() << ";" << this->mSeed.toStdString() << ";";
+  seed << *this->mEpoch << ";";
+  seed << currentEpoch << ";";
+  seed << this->mDirectory->string().size() << ";" << *this->mDirectory << ";";
+  seed << this->mFiles.size() << ";";
+  for (const fs::path& p: this->mFiles)
+    seed << p.string().size() << ";" << p << ";";
+
+  std::vector<std::seed_seq::result_type> v;
+  v.reserve(seed.str().size());
+  for (const char& c: seed.str())
+    v.push_back(c);
+
+  std::seed_seq engine_seed(v.begin(), v.end());
+  std::mt19937 g(engine_seed);
+  std::shuffle(shuffled.begin(), shuffled.end(), g);
+
+  std::vector<fs::path>::size_type ix = shuffled.size() * timeInEpoch / *this->mEpoch;
+  return QString::fromStdString((*this->mDirectory / shuffled[ix]).string());
+}
+
+void FileSelector::onTimeout() {
+  if (!this->mFiles.size())
+    return;
+
+  auto currentTime = std::chrono::system_clock::now();
+  uint64_t currentMinorEpoch = currentTime.time_since_epoch() / (*this->mEpoch / this->mFiles.size());
+  auto nextTime = std::chrono::time_point<std::chrono::system_clock>((currentMinorEpoch + 1) * (*this->mEpoch / this->mFiles.size()));
+  this->timer.start(std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime));
+
+  emit this->selectedChanged();
+}
+
+void FileSelector::update() {
+  this->mFiles = std::set<fs::path>{};
+  for (const fs::directory_entry& entry:
+         fs::recursive_directory_iterator(*this->mDirectory, fs::directory_options::follow_directory_symlink))
+    {
+      this->mFiles.insert(fs::relative(entry, *this->mDirectory));
+    }
+
+  this->onTimeout();
+}
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp
new file mode 100644
index 00000000..72c4f2a7
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <filesystem>
+#include <chrono>
+#include <set>
+#include <optional>
+
+#include <QObject>
+#include <QTimer>
+
+#include <qqmlintegration.h>
+
+class FileSelector : public QObject {
+  Q_OBJECT;
+  Q_PROPERTY(QString directory READ directory WRITE setDirectory NOTIFY directoryChanged REQUIRED);
+  Q_PROPERTY(unsigned int epoch READ epoch WRITE setEpoch NOTIFY epochChanged REQUIRED);
+  Q_PROPERTY(QString seed READ seed WRITE setSeed NOTIFY seedChanged);
+  Q_PROPERTY(QString selected READ selected NOTIFY selectedChanged);
+  QML_ELEMENT;
+
+public:
+  explicit FileSelector(QObject* parent = nullptr);
+
+  QString directory() const;
+  void setDirectory(QString directory);
+
+  unsigned int epoch() const;
+  void setEpoch(unsigned int epoch);
+
+  QString seed() const;
+  void setSeed(QString seed);
+
+  QString selected() const;
+
+signals:
+  void directoryChanged();
+  void epochChanged();
+  void seedChanged();
+  void selectedChanged();
+
+private slots:
+  void onTimeout();
+
+private:
+  std::optional<std::filesystem::path> mDirectory;
+  std::optional<std::chrono::milliseconds> mEpoch;
+  std::set<std::filesystem::path> mFiles;
+  QString mSeed;
+  QTimer timer;
+
+  void update();
+};
diff --git a/accounts/gkleen@sif/shell/quickshell/ActiveWindowDisplay.qml b/accounts/gkleen@sif/shell/quickshell/ActiveWindowDisplay.qml
new file mode 100644
index 00000000..57ade488
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/ActiveWindowDisplay.qml
@@ -0,0 +1,94 @@
+import QtQuick
+import qs.Services
+import Quickshell
+import Quickshell.Widgets
+
+Item {
+  id: activeWindowDisplay
+
+  required property int maxWidth
+  required property var screen
+
+  property var activeWindow: {
+    let currWindowId = Array.from(NiriService.workspaces).find(ws => {
+      return ws.output === screen.name && ws.is_active;
+    })?.active_window_id;
+
+    return currWindowId ? Array.from(NiriService.windows).find(win => win.id == currWindowId) : null;
+  }
+  property var windowEntry: activeWindow ? DesktopEntries.heuristicLookup(activeWindow.app_id) : null
+
+  anchors.verticalCenter: parent.verticalCenter
+  width: activeWindowDisplayContent.width
+  height: parent.height
+
+  Row {
+    id: activeWindowDisplayContent
+
+    width: childrenRect.width
+    height: parent.height
+    anchors.verticalCenter: parent.verticalCenter
+    spacing: 8
+
+    IconImage {
+      id: activeWindowIcon
+
+      height: 14
+      width: 14
+
+      anchors.verticalCenter: parent.verticalCenter
+
+      source: {
+        let icon = activeWindowDisplay.windowEntry?.icon
+        if (typeof icon === 'string' || icon instanceof String) {
+          if (icon.includes("?path=")) {
+            const split = icon.split("?path=")
+            if (split.length !== 2)
+              return icon
+            const name = split[0]
+            const path = split[1]
+            const fileName = name.substring(
+                             name.lastIndexOf("/") + 1)
+            return `file://${path}/${fileName}`
+          } else
+            icon = Quickshell.iconPath(icon);
+          return icon
+        }
+        return ""
+      }
+      asynchronous: true
+      smooth: true
+      mipmap: true
+    }
+
+    Text {
+      id: windowTitle
+
+      width: Math.min(implicitWidth, activeWindowDisplay.maxWidth - activeWindowIcon.width - activeWindowDisplayContent.spacing)
+
+      property var appAliases: { "Firefox": "Mozilla Firefox", "mpv Media Player": "mpv", "Thunderbird": "Mozilla Thunderbird", "Thunderbird (LMU)": "Mozilla Thunderbird" }
+
+      elide: Text.ElideRight
+      maximumLineCount: 1
+      color: "white"
+      anchors.verticalCenter: parent.verticalCenter
+      text: {
+        if (!activeWindowDisplay.activeWindow)
+          return "";
+
+        var title = activeWindowDisplay.activeWindow.title;
+        var appName = activeWindowDisplay.windowEntry?.name;
+        if (appAliases[appName])
+          appName = appAliases[appName];
+        if (appName && title.endsWith(appName)) {
+          const oldTitle = title;
+          title = title.substring(0, title.length - appName.length);
+          title = title.replace(/\s*(—|-)\s*$/, "");
+          if (!title)
+            title = oldTitle;
+        }
+        return title;
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Bar.qml b/accounts/gkleen@sif/shell/quickshell/Bar.qml
index 52f875da..aab1607f 100644
--- a/accounts/gkleen@sif/shell/quickshell/Bar.qml
+++ b/accounts/gkleen@sif/shell/quickshell/Bar.qml
@@ -1,16 +1,13 @@
 import Quickshell
-import Quickshell.Io
-import Quickshell.Services.SystemTray
-import Quickshell.Widgets
-import Custom as Custom
 import QtQuick
-import qs.Services
 
 
 PanelWindow {
   id: bar
 
-  property var modelData
+  required property var screen
+
+  property var calendarMouseArea: clock.calendarMouseArea
 
   anchors {
     top: true
@@ -22,12 +19,11 @@ PanelWindow {
     right: 26 + 8
   }
 
-  screen: modelData
   implicitHeight: 21
   color: "transparent"
 
   Rectangle {
-    color: Qt.rgba(0, 0, 0, 0.66)
+    color: Qt.rgba(0, 0, 0, 0.75)
     anchors.fill: parent
     // bottomLeftRadius: 8
     // bottomRightRadius: 8
@@ -43,74 +39,7 @@ PanelWindow {
     anchors.verticalCenter: parent.verticalCenter
     spacing: 8
 
-    Row {
-      id: workspaces
-
-      property var ignoreWorkspaces: @ignore_workspaces@
-
-      height: parent.height
-      anchors.verticalCenter: parent.verticalCenter
-      spacing: 0
-
-      Repeater {
-        model: {
-          let currWorkspaces = NiriService.workspaces;
-          const ignoreWorkspaces = Array.from(workspaces.ignoreWorkspaces);
-          currWorkspaces = currWorkspaces.filter(ws => ws.is_active || ignoreWorkspaces.every(iws => iws !== ws.name));
-          currWorkspaces.sort((a, b) => {
-            if (NiriService.outputs?.[a.output]?.logical?.x !== NiriService.outputs?.[b.output]?.logical?.x)
-              return NiriService.outputs?.[a.output]?.logical?.x - NiriService.outputs?.[b.output]?.logical?.x
-            if (NiriService.outputs?.[a.output]?.logical?.y !== NiriService.outputs?.[b.output]?.logical?.y)
-              return NiriService.outputs?.[a.output]?.logical?.y - NiriService.outputs?.[b.output]?.logical?.y
-            return a.idx - b.idx;
-          });
-          return currWorkspaces;
-        }
-
-        Rectangle {
-          property var workspaceData: modelData
-
-          width: wsLabel.contentWidth + 8
-          color: {
-            if (mouseArea.containsMouse) {
-              return "#33808080";
-            }
-            return "transparent";
-          }
-          height: parent.height
-          anchors.verticalCenter: parent.verticalCenter
-
-          MouseArea {
-            id: mouseArea
-
-            anchors.fill: parent
-            hoverEnabled: true
-            cursorShape: Qt.PointingHandCursor
-            enabled: true
-            onClicked: {
-              NiriService.sendCommand({ "Action": { "FocusWorkspace": { "reference": { "Id": workspaceData.id } } } }, _ => {})
-            }
-          }
-
-          Text {
-            id: wsLabel
-
-            font.pointSize: 10
-            font.family: "Fira Sans"
-            color: {
-              if (workspaceData.is_active)
-                return "#23fd00";
-              if (workspaceData.active_window_id === null)
-                return "#555";
-              return "white";
-            }
-            anchors.centerIn: parent
-
-            text: workspaceData.name ? workspaceData.name : workspaceData.idx
-          }
-        }
-      }
-    }
+    WorkspaceSwitcher {}
   }
 
   Row {
@@ -121,91 +50,9 @@ PanelWindow {
     anchors.centerIn: parent
     spacing: 5
 
-    Item {
-      id: activeWindowDisplay
-
-      property var activeWindow: {
-        let currWindowId = Array.from(NiriService.workspaces).find(ws => {
-          return ws.output === bar.screen.name && ws.is_active;
-        })?.active_window_id;
-
-        return currWindowId ? Array.from(NiriService.windows).find(win => win.id == currWindowId) : null;
-      }
-      property var windowEntry: activeWindow ? DesktopEntries.heuristicLookup(activeWindow.app_id) : null
-
-      anchors.verticalCenter: parent.verticalCenter
-      width: activeWindowDisplayContent.width
-      height: parent.height
-
-      Row {
-        id: activeWindowDisplayContent
-
-        width: childrenRect.width
-        height: parent.height
-        anchors.verticalCenter: parent.verticalCenter
-        spacing: 8
-
-        IconImage {
-          id: activeWindowIcon
-
-          height: 14
-          width: 14
-
-          anchors.verticalCenter: parent.verticalCenter
-
-          source: {
-            let icon = activeWindowDisplay.windowEntry?.icon
-            if (typeof icon === 'string' || icon instanceof String) {
-              if (icon.includes("?path=")) {
-                const split = icon.split("?path=")
-                if (split.length !== 2)
-                  return icon
-                const name = split[0]
-                const path = split[1]
-                const fileName = name.substring(
-                                 name.lastIndexOf("/") + 1)
-                return `file://${path}/${fileName}`
-              } else
-                icon = Quickshell.iconPath(icon);
-              return icon
-            }
-            return ""
-          }
-          asynchronous: true
-          smooth: true
-          mipmap: true
-        }
-
-        Text {
-          id: windowTitle
-
-          width: Math.min(implicitWidth, bar.width - 2*Math.max(left.width, right.width) - 2*8 - activeWindowIcon.width - activeWindowDisplayContent.spacing)
-
-          property var appAliases: { "Firefox": "Mozilla Firefox", "mpv Media Player": "mpv", "Thunderbird": "Mozilla Thunderbird", "Thunderbird (LMU)": "Mozilla Thunderbird" }
-
-          elide: Text.ElideRight
-          maximumLineCount: 1
-          color: "white"
-          anchors.verticalCenter: parent.verticalCenter
-          text: {
-            if (!activeWindowDisplay.activeWindow)
-              return "";
-
-            var title = activeWindowDisplay.activeWindow.title;
-            var appName = activeWindowDisplay.windowEntry?.name;
-            if (appAliases[appName])
-              appName = appAliases[appName];
-            if (appName && title.endsWith(appName)) {
-              const oldTitle = title;
-              title = title.substring(0, title.length - appName.length);
-              title = title.replace(/\s*(—|-)\s*$/, "");
-              if (!title)
-                title = oldTitle;
-            }
-            return title;
-          }
-        }
-      }
+    ActiveWindowDisplay {
+      screen: bar.screen
+      maxWidth: bar.width - 2*Math.max(left.width, right.width) - 2*8
     }
   }
 
@@ -219,170 +66,22 @@ PanelWindow {
     anchors.verticalCenter: parent.verticalCenter
     spacing: 0
 
-    Item {
-      anchors.verticalCenter: parent.verticalCenter
-      width: systemTrayRow.childrenRect.width
-      height: parent.height
-      clip: true
-
-      Row {
-        id: systemTrayRow
-        anchors.centerIn: parent
-        width: childrenRect.width
-        height: parent.height
-        spacing: 0
-
-        Repeater {
-          model: SystemTray.items.values
-
-          delegate: Item {
-            property var trayItem: modelData
-            property string iconSource: {
-              let icon = trayItem && trayItem.icon
-              if (typeof icon === 'string' || icon instanceof String) {
-                if (icon.includes("?path=")) {
-                  const split = icon.split("?path=")
-                  if (split.length !== 2)
-                    return icon
-                  const name = split[0]
-                  const path = split[1]
-                  const fileName = name.substring(
-                                   name.lastIndexOf("/") + 1)
-                  return `file://${path}/${fileName}`
-                }
-                return icon
-              }
-              return ""
-            }
-
-            width: 16
-            height: parent.height
-            anchors.verticalCenter: parent.verticalCenter
+    SystemTray {}
 
-            IconImage {
-              anchors.centerIn: parent
-              width: parent.width
-              height: parent.width
-              source: parent.iconSource
-              asynchronous: true
-              smooth: true
-              mipmap: true
-            }
-
-            MouseArea {
-              id: trayItemArea
-
-              anchors.fill: parent
-              acceptedButtons: Qt.LeftButton | Qt.RightButton
-              hoverEnabled: true
-              cursorShape: Qt.PointingHandCursor
-              onClicked: mouse => {
-                if (!trayItem)
-                  return
-
-                if (mouse.button === Qt.LeftButton
-                  && !trayItem.onlyMenu) {
-                  trayItem.activate()
-                  return
-                }
-
-                if (trayItem.hasMenu) {
-                  var globalPos = mapToGlobal(0, 0)
-                  var currentScreen = screen || Screen
-                  var screenX = currentScreen.x || 0
-                  var relativeX = globalPos.x - screenX
-                  menuAnchor.menu = trayItem.menu
-                  menuAnchor.anchor.window = bar
-                  menuAnchor.anchor.rect = Qt.rect(
-                      relativeX,
-                      21,
-                      parent.width, 1)
-                  menuAnchor.open()
-                }
-              }
-            }
-          }
-        }
-      }
-      QsMenuAnchor {
-        id: menuAnchor
-      }
-    }
-
-    Rectangle {
+    Item {
       height: parent.height
       width: 4
-      color: "transparent"
     }
 
-    Rectangle {
-      id: kbdWidget
+    KeyboardLayout {}
 
-      property var keyboardAbbrev: { "English (programmer Dvorak)": "dvp", "English (US)": "us" }
-
-      width: kbdLabel.contentWidth + 8
-      color: {
-        if (kbdMouseArea.containsMouse) {
-          return "#33808080";
-        }
-        return "transparent";
-      }
-      height: parent.height
-      anchors.verticalCenter: parent.verticalCenter
-
-      MouseArea {
-        id: kbdMouseArea
-
-        anchors.fill: parent
-        hoverEnabled: true
-        cursorShape: Qt.PointingHandCursor
-        enabled: true
-        onClicked: {
-          NiriService.sendCommand({ "Action": { "SwitchLayout": { "layout": "Next" } } }, _ => {})
-        }
-      }
-
-      Text {
-        id: kbdLabel
-
-        font.pointSize: 10
-        font.family: "Fira Sans"
-        color: {
-          if (NiriService.keyboardLayouts?.current_idx === 0)
-            return "#555";
-          return "white";
-        }
-        anchors.centerIn: parent
-
-        text: {
-          const currentLayout = NiriService.keyboardLayouts?.names?.[NiriService.keyboardLayouts.current_idx];
-          return kbdWidget.keyboardAbbrev[currentLayout] ? kbdWidget.keyboardAbbrev[currentLayout] : currentLayout;
-        }
-      }
-    }
-
-    Rectangle {
+    Item {
       height: parent.height
       width: 4
-      color: "transparent"
     }
 
-    Text {
+    Clock {
       id: clock
-      color: "white"
-
-      anchors.verticalCenter: parent.verticalCenter
-
-      Custom.Chrono {
-        id: chrono
-        format: "W{0:%V-%u} {0:%F} {0:%H:%M:%S%Ez}"
-      }
-
-      text: chrono.date
-
-      font.pointSize: 10
-      font.family: "Fira Sans"
-      font.features: { "tnum": 1 }
     }
   }
 }
\ No newline at end of file
diff --git a/accounts/gkleen@sif/shell/quickshell/Clock.qml b/accounts/gkleen@sif/shell/quickshell/Clock.qml
new file mode 100644
index 00000000..d0c9178b
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Clock.qml
@@ -0,0 +1,266 @@
+import QtQml
+import QtQuick
+import Quickshell
+import Custom as Custom
+import QtQuick.Controls
+import QtQuick.Layouts
+import Quickshell.Widgets
+
+Item {
+  id: clockItem
+
+  property bool calendarPopup: true
+
+  width: clock.contentWidth
+  height: parent.height
+  anchors.verticalCenter: parent.verticalCenter
+
+  WrapperMouseArea {
+    id: clockMouseArea
+
+    anchors.fill: parent
+    hoverEnabled: true
+    enabled: clockItem.calendarPopup
+
+    property real angleRem: 0
+    property real sensitivity: 1 / 120
+
+    function scrollYear(event) {
+      angleRem += event.angleDelta.y;
+      const d = Math.round(angleRem * sensitivity);
+      yearCalendar.year += d;
+      angleRem -= d / sensitivity;
+    }
+
+    onWheel: event => scrollYear(event)
+
+    Item {
+      anchors.fill: parent
+
+      Text {
+        id: clock
+        color: "white"
+
+        anchors.verticalCenter: parent.verticalCenter
+
+        Custom.Chrono {
+          id: chrono
+
+          onDateChanged: clock.text = format("W{0:%V-%u} {0:%F} {0:%H:%M:%S%Ez}")
+        }
+
+        font.pointSize: 10
+        font.family: "Fira Sans"
+        font.features: { "tnum": 1 }
+      }
+    }
+  }
+
+  PopupWindow {
+    id: tooltip
+
+    property bool nextVisible: clockMouseArea.containsMouse || tooltipMouseArea.containsMouse
+
+    anchor {
+      item: clockMouseArea
+      edges: Edges.Bottom | Edges.Left
+    }
+    visible: false
+
+    onNextVisibleChanged: hangTimer.restart()
+
+    Timer {
+      id: hangTimer
+      interval: 100
+      onTriggered: tooltip.visible = tooltip.nextVisible
+    }
+
+    implicitWidth: clockTooltipContent.width
+    implicitHeight: clockTooltipContent.height
+    color: "black"
+
+    onVisibleChanged: {
+      yearCalendar.year = chrono.date.getFullYear();
+      clockMouseArea.angleRem = 0;
+    }
+
+    WrapperMouseArea {
+      id: tooltipMouseArea
+
+      hoverEnabled: true
+      enabled: true
+
+      onWheel: event => clockMouseArea.scrollYear(event)
+
+      anchors.fill: parent
+
+      WrapperItem {
+        id: clockTooltipContent
+
+        margin: 8
+        leftMargin: 0
+
+        ColumnLayout {
+          Text {
+            id: yearLabel
+
+            horizontalAlignment: Text.AlignHCenter
+
+            font.pointSize: 14
+            font.family: "Fira Sans"
+            font.features: { "tnum": 1 }
+            color: "white"
+
+            text: yearCalendar.year
+
+            Layout.fillWidth: true
+            Layout.bottomMargin: 8
+          }
+
+          GridLayout {
+            property int year: chrono.date.getFullYear()
+
+            id: yearCalendar
+
+            columns: 3
+            columnSpacing: 16
+            rowSpacing: 16
+
+            Layout.alignment: Qt.AlignHCenter
+            Layout.fillWidth: false
+
+            Repeater {
+              model: 12
+
+              GridLayout {
+                columns: 2
+
+                required property int index
+                property int month: index
+
+                id: monthCalendar
+
+                Layout.alignment: Qt.AlignTop | Qt.AlignRight
+                Layout.fillWidth: false
+
+                Text {
+                  Layout.column: 1
+                  Layout.fillWidth: true
+
+                  horizontalAlignment: Text.AlignHCenter
+
+                  font.pointSize: 10
+                  font.family: "Fira Sans"
+
+                  text: new Date(yearCalendar.year, monthCalendar.month, 1).toLocaleString(Qt.locale("en_DK"), "MMMM")
+
+                  color: "#ffead3"
+                }
+
+                DayOfWeekRow {
+                  locale: grid.locale
+
+                  Layout.row: 1
+                  Layout.column: 1
+                  Layout.fillWidth: true
+
+                  delegate: WrapperItem {
+                    required property string shortName
+
+                    width: dowLabel.contentWidth + 6
+
+                    Text {
+                      id: dowLabel
+
+                      anchors.fill: parent
+
+                      font.pointSize: 10
+                      font.family: "Fira Sans"
+
+                      text: parent.shortName
+                      color: "#ffcc66"
+
+                      horizontalAlignment: Text.AlignHCenter
+                      verticalAlignment: Text.AlignVCenter
+                    }
+                  }
+                }
+
+                WeekNumberColumn {
+                  month: grid.month
+                  year: grid.year
+                  locale: grid.locale
+
+                  Layout.fillHeight: true
+
+                  delegate: Text {
+                    required property int weekNumber
+
+                    opacity: {
+                      const simple = new Date(weekNumber == 1 && monthCalendar.month == 12 ? yearCalendar.year + 1 : yearCalendar.year, 0, 1 + (weekNumber - 1) * 7);
+                      const dayOfWeek = simple.getDay();
+                      const isoWeekStart = simple;
+
+                      isoWeekStart.setDate(simple.getDate() - dayOfWeek + 1);
+                      if (dayOfWeek > 4) {
+                          isoWeekStart.setDate(isoWeekStart.getDate() + 7);
+                      }
+
+                      for (let i = 0; i < 7; i++) {
+                        const dayInWeek = new Date(isoWeekStart);
+                        dayInWeek.setDate(dayInWeek.getDate() + i);
+                        if (dayInWeek.getMonth() == monthCalendar.month)
+                          return 1;
+                      }
+
+                      return 0;
+                    }
+
+                    font.pointSize: 10
+                    font.family: "Fira Sans"
+                    font.features: { "tnum": 1 }
+
+                    text: weekNumber
+                    color: "#99ffdd"
+
+                    horizontalAlignment: Text.AlignRight
+                    verticalAlignment: Text.AlignVCenter
+                  }
+                }
+
+                MonthGrid {
+                  id: grid
+
+                  year: yearCalendar.year
+                  month: monthCalendar.month
+                  locale: Qt.locale("en_DK")
+
+                  Layout.fillWidth: true
+                  Layout.fillHeight: true
+
+                  delegate: Text {
+                      required property var model
+
+                      opacity: model.month === monthCalendar.month ? 1 : 0
+
+                      font.pointSize: 10
+                      font.family: "Fira Sans"
+                      font.features: { "tnum": 1 }
+
+                      property bool today: chrono.date.getFullYear() == model.year && chrono.date.getMonth() == model.month && chrono.date.getDate() == model.day
+
+                      text: model.day
+                      color: today ? "#ff6699" : "white"
+
+                      horizontalAlignment: Text.AlignRight
+                      verticalAlignment: Text.AlignVCenter
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml b/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml
new file mode 100644
index 00000000..bc3750f9
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml
@@ -0,0 +1,106 @@
+import Quickshell
+import QtQuick
+import qs.Services
+import Quickshell.Widgets
+
+Item {
+  width: kbdLabel.contentWidth + 8
+  height: parent.height
+  anchors.verticalCenter: parent.verticalCenter
+
+  WrapperMouseArea {
+    id: kbdMouseArea
+
+    anchors.fill: parent
+
+    hoverEnabled: true
+    cursorShape: Qt.PointingHandCursor
+    enabled: true
+    onClicked: {
+      NiriService.sendCommand({ "Action": { "SwitchLayout": { "layout": "Next" } } }, _ => {})
+    }
+    onWheel: event => {
+      NiriService.sendCommand({ "Action": { "SwitchLayout": { "layout": event.angleDelta > 0 ? "Next" : "Prev" } } }, _ => {})
+    }
+
+    Rectangle {
+      id: kbdWidget
+
+      property var keyboardAbbrev: { "English (programmer Dvorak)": "dvp", "English (US)": "us" }
+
+      anchors.fill: parent
+      color: {
+        if (kbdMouseArea.containsMouse) {
+          return "#33808080";
+        }
+        return "transparent";
+      }
+
+      Text {
+        id: kbdLabel
+
+        font.pointSize: 10
+        font.family: "Fira Sans"
+        color: {
+          if (NiriService.keyboardLayouts?.current_idx === 0)
+            return "#555";
+          return "white";
+        }
+        anchors.centerIn: parent
+
+        text: {
+          const currentLayout = NiriService.keyboardLayouts?.names?.[NiriService.keyboardLayouts.current_idx];
+          if (!currentLayout)
+            return "";
+          return kbdWidget.keyboardAbbrev[currentLayout] ? kbdWidget.keyboardAbbrev[currentLayout] : currentLayout;
+        }
+      }
+    }
+  }
+
+  PopupWindow {
+    id: tooltip
+
+    property bool nextVisible: kbdMouseArea.containsMouse || tooltipMouseArea.containsMouse
+
+    anchor {
+      item: kbdMouseArea
+      edges: Edges.Bottom | Edges.Left
+    }
+    visible: false
+
+    onNextVisibleChanged: hangTimer.restart()
+
+    Timer {
+      id: hangTimer
+      interval: 100
+      onTriggered: tooltip.visible = tooltip.nextVisible
+    }
+
+    implicitWidth: kbdTooltipText.contentWidth + 16
+    implicitHeight: kbdTooltipText.contentHeight + 16
+    color: "black"
+
+    WrapperMouseArea {
+      id: tooltipMouseArea
+
+      hoverEnabled: true
+      enabled: true
+
+      anchors.centerIn: parent
+
+      Text {
+        id: kbdTooltipText
+
+        font.pointSize: 10
+        font.family: "Fira Sans"
+        color: "white"
+
+        text: {
+          const currentLayout = NiriService.keyboardLayouts?.names?.[NiriService.keyboardLayouts.current_idx];
+          return currentLayout || "";
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml b/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml
new file mode 100644
index 00000000..7cb1cc67
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml
@@ -0,0 +1,259 @@
+import Quickshell
+import Quickshell.Wayland
+import Quickshell.Io
+import Quickshell.Services.Pam
+import Quickshell.Widgets
+import QtQuick.Effects
+import QtQuick.Layouts
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Fusion
+import qs.Services
+// import QtQml.Models
+
+Scope {
+  id: lockscreen
+
+  property string currentText: ""
+
+  PamContext {
+    id: pam
+
+    property list<var> messages: []
+
+    config: "quickshell"
+    onCompleted: result => {
+      if (result === PamResult.Success) {
+        lock.locked = false;
+      }
+    }
+    onPamMessage: {
+      messages = Array.from(messages).concat([{ "text": pam.message, "error": pam.messageIsError }])
+    }
+    onActiveChanged: {
+      messages = [];
+    }
+  }
+
+  IpcHandler {
+    target: "Lockscreen"
+
+    function setLocked(locked: bool): void { lock.locked = locked; }
+    function getLocked(): bool { return lock.locked; }
+  }
+
+  WlSessionLock {
+    id: lock
+
+    onLockedChanged: {
+      if (!locked && pam.active)
+        pam.abort();
+    }
+
+    WlSessionLockSurface {
+      id: lockSurface
+
+      color: "#000000"
+
+      Item {
+        id: background
+
+        anchors.fill: parent
+
+        property Img current: one
+        property string source: selector.selected
+
+        WallpaperSelector {
+          id: selector
+          seed: lockSurface.screen?.name || ""
+        }
+
+        onSourceChanged: {
+          if (!source)
+            current = null;
+          else if (current === one)
+            two.update()
+          else
+            one.update()
+        }
+
+        Img { id: one }
+        Img { id: two }
+
+        component Img: Item {
+          id: img
+
+          property string source
+
+          function update() {
+            source = background.source || ""
+          }
+
+          anchors.fill: parent
+
+          Image {
+            id: imageSource
+
+            source: img.source
+            sourceSize: Qt.size(parent.width, parent.height)
+            fillMode: Image.PreserveAspectCrop
+            smooth: true
+            visible: false
+            asynchronous: true
+            cache: false
+
+            onStatusChanged: {
+              if (status === Image.Ready) {
+                background.current = img
+              }
+            }
+          }
+
+          MultiEffect {
+            id: imageEffect
+
+            source: imageSource
+            anchors.fill: parent
+            blurEnabled: true
+            blur: 1
+            blurMax: 64
+            blurMultiplier: 2
+
+            opacity: 0
+
+            states: State {
+              name: "visible"
+              when: background.current === img
+
+              PropertyChanges {
+                imageEffect.opacity: 1
+              }
+              StateChangeScript {
+                name: "unloadOther"
+                script: {
+                  if (img === one)
+                    two.source = ""
+                  if (img === two)
+                    one.source = ""
+                }
+              }
+            }
+
+            transitions: Transition {
+              SequentialAnimation {
+                NumberAnimation {
+                  target: imageEffect
+                  properties: "opacity"
+                  duration: 5000
+                  easing.type: Easing.OutCubic
+                }
+                ScriptAction {
+                  scriptName: "unloadOther"
+                }
+              }
+            }
+          }
+        }
+      }
+
+      Item {
+        anchors {
+          top: lockSurface.top
+          left: lockSurface.left
+          right: lockSurface.right
+        }
+
+        implicitWidth: lockSurface.width
+        implicitHeight: 21
+
+        Rectangle {
+          anchors.fill: parent
+          color: Qt.rgba(0, 0, 0, 0.75)
+        }
+
+        Clock {
+          anchors.centerIn: parent
+          calendarPopup: false
+        }
+      }
+
+      WrapperRectangle {
+        id: unlockUi
+
+        Keys.onPressed: event => {
+          if (!pam.active) {
+            event.accepted = true;
+            pam.start();
+          }
+        }
+        focus: !passwordBox.visible
+
+        visible: pam.active
+
+        color: Qt.rgba(0, 0, 0, 0.75)
+        margin: 8
+
+        anchors.centerIn: parent
+
+        ColumnLayout {
+          spacing: 4
+
+          BusyIndicator {
+            visible: running
+            running: !Array.from(pam.messages).length && !pam.responseRequired
+          }
+
+          Repeater {
+            model: pam.messages
+
+            Text {
+              required property var modelData
+
+              font.pointSize: 10
+              font.family: "Fira Sans"
+              color: modelData.error ? "#f28a21" : "#ffffff"
+
+              text: modelData.text
+
+              Layout.fillWidth: true
+              horizontalAlignment: Text.AlignHCenter
+            }
+          }
+
+          TextField {
+            id: passwordBox
+
+            visible: pam.responseRequired
+            echoMode: pam.responseVisible ? TextInput.Normal : TextInput.Password
+            inputMethodHints: Qt.ImhSensitiveData
+
+            onTextChanged: lockscreen.currentText = passwordBox.text
+            onAccepted: {
+              passwordBox.readOnly = true;
+              pam.respond(lockscreen.currentText);
+            }
+
+            Connections {
+              target: lockscreen
+              function onCurrentTextChanged() {
+                passwordBox.text = lockscreen.currentText
+              }
+            }
+            Connections {
+              target: pam
+              function onResponseRequiredChanged() {
+                if (pam.responseRequired)
+                  passwordBox.readOnly = false;
+                  passwordBox.focus = true;
+                  passwordBox.selectAll();
+              }
+            }
+
+            Layout.topMargin: 4
+            Layout.fillWidth: true
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml b/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
index 914152e1..af522ec4 100644
--- a/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
+++ b/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
@@ -13,10 +13,6 @@ Singleton {
   property var windows: []
   readonly property string socketPath: Quickshell.env("NIRI_SOCKET")
 
-  onKeyboardLayoutsChanged: {
-    console.log(JSON.stringify(keyboardLayouts));
-  }
-
   function refreshOutputs() {
     commandSocket.sendCommand("Outputs", data => {
       outputs = data.Ok.Outputs;
@@ -32,9 +28,12 @@ Singleton {
     path: root.socketPath
     connected: true
 
+    property bool acked: false
+
     onConnectionStateChanged: {
       if (connected) {
-        write('"EventStream"\n')
+        acked = false;
+        write('"EventStream"\n');
       }
     }
 
@@ -70,6 +69,11 @@ Singleton {
             eventWindowUrgencyChanged(event.WindowUrgencyChanged);
           else if (event.WindowLayoutsChanged)
             eventWindowLayoutsChanged(event.WindowLayoutsChanged);
+          else if (event.Ok && !eventStreamSocket.acked) { eventStreamSocket.acked = true; }
+          else if (event.OverviewOpenedOrClosed) {}
+          else if (event.ConfigLoaded) {}
+          else
+            console.log(JSON.stringify(event));
         } catch (e) {
           console.warn("NiriService: Failed to parse event:", line, e)
         }
@@ -157,10 +161,10 @@ Singleton {
   }
   function eventWindowOpenedOrChanged(data) {
     root.windows = Array.from(root.windows).map(win => {
-      if (win.id === data.window.id)
-        return data.window;
+      if (data.window.is_focused)
+        win.is_focused = false;
       return win;
-    });
+    }).filter(win => win.id !== data.window.id).concat([data.window]);
   }
   function eventWindowClosed(data) {
     root.windows = Array.from(root.windows).filter(win => win.id !== data.id);
diff --git a/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml b/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml
new file mode 100644
index 00000000..3c524955
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml
@@ -0,0 +1,8 @@
+import Custom as Custom
+
+Custom.FileSelector {
+  id: root
+
+  directory: @wallpapers@
+  epoch: 72000000
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/SystemTray.qml b/accounts/gkleen@sif/shell/quickshell/SystemTray.qml
new file mode 100644
index 00000000..55b1690e
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/SystemTray.qml
@@ -0,0 +1,159 @@
+import QtQuick
+import Quickshell
+import Quickshell.Widgets
+import Quickshell.Services.SystemTray
+
+Item {
+  anchors.verticalCenter: parent.verticalCenter
+  width: systemTrayRow.childrenRect.width
+  height: parent.height
+  clip: true
+
+  Row {
+    id: systemTrayRow
+    anchors.centerIn: parent
+    width: childrenRect.width
+    height: parent.height
+    spacing: 0
+
+    Repeater {
+      model: ScriptModel {
+        values: {
+          var trayItems = Array.from(SystemTray.items.values).filter(item => item.status !== Status.Passive);
+          trayItems.sort((a, b) => a.category !== b.category ? b.category - a.category : a.id.localeCompare(b.id))
+          return trayItems;
+        }
+      }
+
+      delegate: Item {
+        id: trayItemWrapper
+
+        property var trayItem: modelData
+        property string iconSource: {
+          let icon = trayItem && trayItem.icon
+          if (typeof icon === 'string' || icon instanceof String) {
+            if (icon.includes("?path=")) {
+              const split = icon.split("?path=")
+              if (split.length !== 2)
+                return icon
+              const name = split[0]
+              const path = split[1]
+              const fileName = name.substring(
+                               name.lastIndexOf("/") + 1)
+              return `file://${path}/${fileName}`
+            }
+            return icon
+          }
+          return ""
+        }
+
+        width: 16
+        height: parent.height
+        anchors.verticalCenter: parent.verticalCenter
+
+        WrapperMouseArea {
+          id: trayItemArea
+
+          anchors.fill: parent
+          acceptedButtons: Qt.LeftButton | Qt.RightButton
+          hoverEnabled: true
+          cursorShape: trayItem.onlyMenu ? Qt.ArrowCursor : Qt.PointingHandCursor
+          onClicked: mouse => {
+            if (!trayItem)
+              return
+
+            if (mouse.button === Qt.LeftButton
+              && !trayItem.onlyMenu) {
+              trayItem.activate()
+              return
+            }
+
+            if (trayItem.hasMenu) {
+              var globalPos = mapToGlobal(0, 0)
+              var currentScreen = screen || Screen
+              var screenX = currentScreen.x || 0
+              var relativeX = globalPos.x - screenX
+              menuAnchor.menu = trayItem.menu
+              menuAnchor.anchor.window = bar
+              menuAnchor.anchor.rect = Qt.rect(
+                  relativeX,
+                  21,
+                  parent.width, 1)
+              menuAnchor.open()
+            }
+          }
+
+          IconImage {
+            anchors.centerIn: parent
+            width: parent.width
+            height: parent.width
+            source: trayItemWrapper.iconSource
+            asynchronous: true
+            smooth: true
+            mipmap: true
+          }
+        }
+
+        PopupWindow {
+          id: tooltip
+
+          property bool nextVisible: (trayItem.tooltipTitle || trayItem.tooltipDescription) && (trayItemArea.containsMouse || tooltipMouseArea.containsMouse) && !menuAnchor.visible
+
+          anchor {
+            item: trayItemArea
+            edges: Edges.Bottom
+          }
+
+          visible: false
+          onNextVisibleChanged: hangTimer.restart()
+
+          Timer {
+            id: hangTimer
+            interval: 100
+            onTriggered: tooltip.visible = tooltip.nextVisible
+          }
+
+          color: "black"
+
+          implicitWidth: Math.max(tooltipTitle.contentWidth, tooltipDescription.contentWidth) + 16
+          implicitHeight: tooltipTitle.contentHeight + tooltipDescription.contentHeight + 16
+
+          WrapperMouseArea {
+            id: tooltipMouseArea
+
+            hoverEnabled: true
+            enabled: true
+
+            margin: 8
+
+            Column {
+              Text {
+                id: tooltipTitle
+
+                font.pointSize: 10
+                font.family: "Fira Sans"
+                font.bold: true
+                color: "white"
+
+                text: trayItem.tooltipTitle
+              }
+
+              Text {
+                id: tooltipDescription
+
+                font.pointSize: 10
+                font.family: "Fira Sans"
+                color: "white"
+
+                text: trayItem.tooltipDescription
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  QsMenuAnchor {
+    id: menuAnchor
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml b/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml
new file mode 100644
index 00000000..de31915f
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml
@@ -0,0 +1,85 @@
+import QtQuick
+import Quickshell
+import qs.Services
+
+Item {
+  id: root
+
+  anchors.fill: parent
+
+  required property string screen
+
+  property Img current: one
+  property string source: selector.selected
+
+  WallpaperSelector {
+    id: selector
+    seed: screen
+  }
+
+  onSourceChanged: {
+    if (!source)
+      current = null;
+    else if (current === one)
+      two.update()
+    else
+      one.update()
+  }
+
+  Img { id: one }
+  Img { id: two }
+
+  component Img: Image {
+    id: img
+
+    function update() {
+      source = root.source || ""
+    }
+
+    anchors.fill: parent
+    fillMode: Image.PreserveAspectCrop
+    smooth: true
+    asynchronous: true
+    cache: false
+
+    opacity: 0
+
+    onStatusChanged: {
+      if (status === Image.Ready) {
+        root.current = this
+      }
+    }
+
+    states: State {
+      name: "visible"
+      when: root.current === img
+
+      PropertyChanges {
+        img.opacity: 1
+      }
+      StateChangeScript {
+        name: "unloadOther"
+        script: {
+          if (img === one)
+            two.source = ""
+          if (img === two)
+            one.source = ""
+        }
+      }
+    }
+
+    transitions: Transition {
+      SequentialAnimation {
+        NumberAnimation {
+          target: img
+          properties: "opacity"
+          duration: 5000
+          easing.type: Easing.OutCubic
+        }
+        ScriptAction {
+          scriptName: "unloadOther"
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml b/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml
new file mode 100644
index 00000000..c8c017c3
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml
@@ -0,0 +1,201 @@
+import Quickshell
+import QtQuick
+import qs.Services
+import Quickshell.Widgets
+import QtQuick.Layouts
+
+Row {
+  id: workspaces
+
+  property var ignoreWorkspaces: @ignore_workspaces@
+
+  height: parent.height
+  anchors.verticalCenter: parent.verticalCenter
+  spacing: 0
+
+  Repeater {
+    model: ScriptModel {
+      values: {
+        let currWorkspaces = NiriService.workspaces;
+        const ignoreWorkspaces = Array.from(workspaces.ignoreWorkspaces);
+        currWorkspaces = currWorkspaces.filter(ws => ws.is_active || ignoreWorkspaces.every(iws => iws !== ws.name));
+        currWorkspaces.sort((a, b) => {
+          if (NiriService.outputs?.[a.output]?.logical?.x !== NiriService.outputs?.[b.output]?.logical?.x)
+            return NiriService.outputs?.[a.output]?.logical?.x - NiriService.outputs?.[b.output]?.logical?.x
+          if (NiriService.outputs?.[a.output]?.logical?.y !== NiriService.outputs?.[b.output]?.logical?.y)
+            return NiriService.outputs?.[a.output]?.logical?.y - NiriService.outputs?.[b.output]?.logical?.y
+          return a.idx - b.idx;
+        });
+        return currWorkspaces;
+      }
+    }
+
+    Item {
+      id: wsItem
+
+      property var workspaceData: modelData
+
+      width: wsLabel.contentWidth + 8
+      height: parent.height
+      anchors.verticalCenter: parent.verticalCenter
+
+      WrapperMouseArea {
+        id: mouseArea
+
+        anchors.fill: parent
+
+        hoverEnabled: true
+        cursorShape: Qt.PointingHandCursor
+        enabled: true
+        onClicked: {
+          NiriService.sendCommand({ "Action": { "FocusWorkspace": { "reference": { "Id": workspaceData.id } } } }, _ => {})
+        }
+
+        Rectangle {
+          anchors.fill: parent
+
+          color: {
+            if (mouseArea.containsMouse) {
+              return "#33808080";
+            }
+            return "transparent";
+          }
+
+          Text {
+            id: wsLabel
+
+            anchors.centerIn: parent
+
+            font.pointSize: 10
+            font.family: "Fira Sans"
+            color: {
+              if (workspaceData.is_active)
+                return "#23fd00";
+              if (workspaceData.active_window_id === null)
+                return "#555";
+              return "white";
+            }
+
+            text: workspaceData.name ? workspaceData.name : workspaceData.idx
+          }
+        }
+      }
+
+      PopupWindow {
+        id: tooltip
+
+        property bool nextVisible: (mouseArea.containsMouse || tooltipMouseArea.containsMouse) && [...windowsModel.values].length > 0
+
+        anchor {
+          item: mouseArea
+          edges: Edges.Bottom | Edges.Left
+        }
+        visible: false
+
+        onNextVisibleChanged: hangTimer.restart()
+
+        Timer {
+          id: hangTimer
+          interval: 100
+          onTriggered: tooltip.visible = tooltip.nextVisible
+        }
+
+        implicitWidth: tooltipContent.implicitWidth
+        implicitHeight: tooltipContent.implicitHeight
+        color: "black"
+
+        WrapperMouseArea {
+          id: tooltipMouseArea
+
+          hoverEnabled: true
+          enabled: true
+
+          anchors.fill: parent
+
+          WrapperItem {
+            id: tooltipContent
+
+            margin: 0
+
+            ColumnLayout  {
+              spacing: 0
+
+              Repeater {
+                model: ScriptModel {
+                  id: windowsModel
+
+                  values: {
+                    let currWindows = Array.from(NiriService.windows).filter(win => win.workspace_id == wsItem.workspaceData.id);
+                    currWindows.sort((a, b) => {
+                      if (a.is_floating !== b.is_floating)
+                        return b.is_floating - a.is_floating;
+                      if (a.layout.tile_pos_in_workspace_view?.[0] !== b.layout.tile_pos_in_workspace_view?.[0])
+                        return a.layout.tile_pos_in_workspace_view?.[0] - b.layout.tile_pos_in_workspace_view?.[0]
+                      if (a.layout.tile_pos_in_workspace_view?.[1] !== b.layout.tile_pos_in_workspace_view?.[1])
+                        return a.layout.tile_pos_in_workspace_view?.[1] - b.layout.tile_pos_in_workspace_view?.[1]
+                      if (a.layout.pos_in_scrolling_layout?.[0] !== b.layout.pos_in_scrolling_layout?.[0])
+                        return a.layout.pos_in_scrolling_layout?.[0] - b.layout.pos_in_scrolling_layout?.[0]
+                      if (a.layout.pos_in_scrolling_layout?.[1] !== b.layout.pos_in_scrolling_layout?.[1])
+                        return a.layout.pos_in_scrolling_layout?.[1] - b.layout.pos_in_scrolling_layout?.[1]
+                      if (a.app_id !== b.app_id)
+                        return a.app_id.localeCompare(b.app_id);
+
+                      return a.title.localeCompare(b.title);
+                    });
+                    return currWindows;
+                  }
+                }
+
+                WrapperMouseArea {
+                  id: windowMouseArea
+
+                  property var windowData: modelData
+
+                  hoverEnabled: true
+                  cursorShape: Qt.PointingHandCursor
+                  enabled: true
+
+                  Layout.fillWidth: true
+
+                  onClicked: {
+                    NiriService.sendCommand({ "Action": { "FocusWindow": { "id": windowData.id } } }, _ => {})
+                  }
+
+                  WrapperRectangle {
+                    color: windowMouseArea.containsMouse ? "#33808080" : "transparent";
+
+                    anchors.fill: parent
+
+                    WrapperItem {
+                      anchors.fill: parent
+
+                      margin: 4
+
+                      Text {
+                        id: windowLabel
+
+                        font.pointSize: 10
+                        font.family: "Fira Sans"
+                        color: {
+                          if (windowData.is_focused)
+                            return "#23fd00";
+                          if (NiriService.workspaces.find(ws => ws.id == windowData.workspace_id)?.active_window_id == windowData.id)
+                            return "white";
+                          return "#555";
+                        }
+
+                        text: windowData.title
+
+                        horizontalAlignment: Text.AlignLeft
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/shell.qml b/accounts/gkleen@sif/shell/quickshell/shell.qml
index 2abd1fef..1da9457d 100644
--- a/accounts/gkleen@sif/shell/quickshell/shell.qml
+++ b/accounts/gkleen@sif/shell/quickshell/shell.qml
@@ -1,6 +1,7 @@
 //@ pragma UseQApplication
 
 import Quickshell
+import Quickshell.Wayland
 
 ShellRoot {
   settings.watchFiles: false
@@ -8,8 +9,36 @@ ShellRoot {
   Variants {
     model: Quickshell.screens
 
-    delegate: Bar {
-      modelData: item
+    delegate: Scope {
+      id: screenScope
+
+      required property var modelData
+
+      PanelWindow {
+        id: bgWindow
+
+        screen: screenScope.modelData
+
+        WlrLayershell.layer: WlrLayer.Background
+        WlrLayershell.exclusionMode: ExclusionMode.Ignore
+
+        anchors.top: true
+        anchors.bottom: true
+        anchors.left: true
+        anchors.right: true
+
+        color: "black"
+
+        WallpaperBackground {
+          screen: bgWindow.screen.name
+        }
+      }
+
+      Bar {
+        screen: screenScope.modelData
+      }
     }
   }
+
+  Lockscreen {}
 }