5 files changed, 256 insertions, 33 deletions

diff --git a/accounts/gkleen@sif/niri/default.nix b/accounts/gkleen@sif/niri/default.nix
index 4a207589..7e187c84 100644
--- a/accounts/gkleen@sif/niri/default.nix
+++ b/accounts/gkleen@sif/niri/default.nix
@@ -28,7 +28,11 @@ let
 
       while IFS=$'\n' read -r window_json; do
         if [[ -n $(jq -c "$window_select" <<<"$window_json") ]]; then
-          niri msg action focus-window --id "$(jq -r '.id' <<<"$window_json")"
+          if jq -e '.is_focused' <<<"$window_json" >/dev/null; then
+            niri msg action focus-workspace-previous
+          else
+            niri msg action focus-window --id "$(jq -r '.id' <<<"$window_json")"
+          fi
           exit 0
         fi
       done < <(niri msg -j windows | jq -c '.[]')
@@ -89,7 +93,8 @@ let
       active_output="$(jq -r '.[] | select(.is_focused) | .output' <<<"$workspaces_json")"
       active_workspace="$(jq -r '.[] | select(.is_focused) | .id' <<<"$workspaces_json")"
 
-      workspace_json="$(jq -c --arg active_output "$active_output" 'map(select(.output == $active_output and .name == null)) | sort_by(.idx) | .[0]' <<<"$workspaces_json")"
+      history_json="$(socat STDIO UNIX-CONNECT:"$XDG_RUNTIME_DIR"/niri-workspace-history.sock)"
+      workspace_json="$(jq -c --arg active_output "$active_output" --argjson history "$history_json" 'map(select(.output == $active_output and .name == null)) | map({"value": ., "history_idx": ((. as $workspace | ($history[$active_output] | index($workspace | .id))) as $active_idx | if $active_idx then $active_idx else ($history[$active_output] | length) + 1 end)}) | sort_by(.history_idx, .value.idx) | map(.value) | .[0]' <<<"$workspaces_json")"
       [[ -n $workspace_json && $workspace_json != null ]] || exit 0
       jq --arg active_workspace "$active_workspace" -c "$action" <<<"$workspace_json" | tee /dev/stderr | socat STDIO "$NIRI_SOCKET"
     '';
@@ -156,6 +161,113 @@ in {
       ];
     };
 
+    systemd.user.sockets.niri-workspace-history = {
+      Socket = {
+        ListenStream = "%t/niri-workspace-history.sock";
+        SocketMode = "0600";
+      };
+    };
+    systemd.user.services.niri-workspace-history = {
+      Unit = {
+        BindsTo = [ "niri.service" ];
+        After = [ "niri.service" ];
+      };
+      Install = {
+        WantedBy = [ "niri.service" ];
+      };
+      Service = {
+        Type = "simple";
+        Sockets = [ "niri-workspace-history.socket" ];
+        ExecStart = pkgs.writers.writePython3 "niri-workspace-history" {} ''
+          import os
+          import socket
+          import json
+          import sys
+          from collections import defaultdict
+          from threading import Thread, Lock
+          from socketserver import StreamRequestHandler, ThreadingTCPServer
+          from contextlib import contextmanager
+          from io import TextIOWrapper
+
+
+          @contextmanager
+          def detaching(thing):
+              try:
+                  yield thing
+              finally:
+                  thing.detach()
+
+
+          workspace_history = defaultdict(list)
+          history_lock = Lock()
+
+
+          def monitor_niri():
+              workspaces = list()
+
+              def focus_workspace(output, workspace):
+                  global workspace_history, history_lock
+
+                  with history_lock:
+                      workspace_history[output] = [workspace] + [ws for ws in workspace_history[output] if ws != workspace]  # noqa: E501
+                      print(json.dumps(workspace_history), file=sys.stderr)
+
+              sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+              sock.connect(os.environ["NIRI_SOCKET"])
+              sock.send(b"\"EventStream\"\n")
+              for line in sock.makefile(buffering=1, encoding='utf-8'):
+                  if line_json := json.loads(line):
+                      if "WorkspacesChanged" in line_json:
+                          workspaces = line_json["WorkspacesChanged"]["workspaces"]
+                          for ws in workspaces:
+                              if ws["is_focused"]:
+                                  focus_workspace(ws["output"], ws["id"])
+                      if "WorkspaceActivated" in line_json:
+                          for ws in workspaces:
+                              if ws["id"] != line_json["WorkspaceActivated"]["id"]:
+                                  continue
+                              focus_workspace(ws["output"], ws["id"])
+                              break
+
+
+          class RequestHandler(StreamRequestHandler):
+              def handle(self):
+                  global workspace_history, history_lock
+
+                  with detaching(TextIOWrapper(self.wfile, encoding='utf-8', write_through=True)) as out:  # noqa: E501
+                      with history_lock:
+                          json.dump(workspace_history, out)
+
+
+          class Server(ThreadingTCPServer):
+              def __init__(self):
+                  ThreadingTCPServer.__init__(self, ("", 8000), RequestHandler, bind_and_activate=False)  # noqa: E501
+                  self.socket = socket.fromfd(3, self.address_family, self.socket_type)
+
+
+          def run_server():
+              with Server() as server:
+                  server.serve_forever()
+
+
+          niri = Thread(target=monitor_niri)
+          niri.daemon = True
+          niri.start()
+
+          server_thread = Thread(target=run_server)
+          server_thread.daemon = True
+          server_thread.start()
+
+          while True:
+              server_thread.join(timeout=0.5)
+              niri.join(timeout=0.5)
+
+              if not (niri.is_alive() and server_thread.is_alive()):
+                  break
+        '';
+      };
+    };
+
     programs.niri.settings = {
       prefer-no-csd = true;
       screenshot-path = "${config.home.homeDirectory}/screenshots";
@@ -209,6 +321,7 @@ in {
 
       animations = {
         slowdown = 0.5;
+        workspace-switch = null;
       };
 
       layout = {
@@ -274,13 +387,14 @@ in {
       };
 
       window-rules = [
-        # {
-        #   geometry-corner-radius =
-        #     let
-        #       allCorners = r: { bottom-left = r; bottom-right = r; top-left = r; top-right = r; };
-        #     in allCorners 4.;
-        #   clip-to-geometry = true;
-        # }
+        {
+          matches = [ { is-floating = true; } ];
+          geometry-corner-radius =
+            let
+              allCorners = r: { bottom-left = r; bottom-right = r; top-left = r; top-right = r; };
+            in allCorners 8.;
+          clip-to-geometry = true;
+        }
         {
           matches = [ { app-id = "^com\.saivert\.pwvucontrol$"; } ];
           open-on-workspace = "pwctl";
@@ -397,6 +511,7 @@ in {
           matches = [
             { app-id = "^Gimp-"; title = "^Quit GIMP$"; }
             { app-id = "^org\.kde\.polkit-kde-authentication-agent-1$"; }
+            { app-id = "^xdg-desktop-portal-gtk$"; }
           ];
           open-floating = true;
         }
diff --git a/accounts/gkleen@sif/niri/waybar.nix b/accounts/gkleen@sif/niri/waybar.nix
index c3820508..3f1f8119 100644
--- a/accounts/gkleen@sif/niri/waybar.nix
+++ b/accounts/gkleen@sif/niri/waybar.nix
@@ -61,7 +61,7 @@ in {
                       text = f"<span font=\"Symbols Nerd Font Mono\" size=\"90%\">{icon}</span>"  # noqa: E501
                       if is_silent:
                           text = f"<span color=\"#ffffff\">{text}</span>"
-                      print(json.dumps({'text': text}, separators=(',', ':')), flush=True)  # noqa: E501
+                      print(json.dumps({'text': text, 'tooltip': ', '.join(modes)}, separators=(',', ':')), flush=True)  # noqa: E501
 
                   async def on_properties_changed(interface_name, changed_properties, invalidated_properties):  # noqa: E501
                       if "Modes" not in invalidated_properties:
@@ -122,13 +122,13 @@ in {
           };
           "custom/worktime" = {
             interval = 60;
-            exec = lib.getExe pkgs.worktime;
-            tooltip = false;
+            exec = "${lib.getExe pkgs.worktime} time --waybar";
+            return-type = "json";
           };
           "custom/worktime-today" = {
             interval = 60;
-            exec = "${lib.getExe pkgs.worktime} today";
-            tooltip = false;
+            exec = "${lib.getExe pkgs.worktime} today --waybar";
+            return-type = "json";
           };
           "niri/workspaces" = {
             ignore = ["eff" "pwctl" "kpxc" "bmgr" "edit" "term"];
@@ -323,6 +323,12 @@ in {
         #idle_inhibitor.activated {
           color: @white;
         }
+        #custom-worktime.running, #custom-worktime-today.running {
+          color: @white;
+        }
+        #custom-worktime.over, #custom-worktime-today.over {
+          color: @orange;
+        }
 
         #idle_inhibitor {
           padding-top: 1px;
diff --git a/overlays/swayosd.nix b/overlays/swayosd/default.nix
index 61c865e7..28c8f1b9 100644
--- a/overlays/swayosd.nix
+++ b/overlays/swayosd/default.nix
@@ -23,5 +23,8 @@
       udev
       sassc
     ];
+    patches = (oldAttrs.patches or []) ++ [
+      ./exponential.patch
+    ];
   });
 }
diff --git a/overlays/swayosd/exponential.patch b/overlays/swayosd/exponential.patch
new file mode 100644
index 00000000..eb90d739
--- /dev/null
+++ b/overlays/swayosd/exponential.patch
@@ -0,0 +1,57 @@
+diff --git a/src/brightness_backend/brightnessctl.rs b/src/brightness_backend/brightnessctl.rs
+index ccb0e11..740fdb6 100644
+--- a/src/brightness_backend/brightnessctl.rs
++++ b/src/brightness_backend/brightnessctl.rs
+@@ -107,10 +107,21 @@ impl VirtualDevice {
+                }
+        }
+ 
+-       fn set_percent(&mut self, mut val: u32) -> anyhow::Result<()> {
+-               val = val.clamp(0, 100);
+-               self.current = self.max.map(|max| val * max / 100);
+-               let _: String = self.run(("set", &*format!("{val}%")))?;
++        fn val_to_percent(&mut self, val: u32) -> u32 {
++                return ((val as f64 / self.get_max() as f64).powf(0.25) * 100_f64).round() as u32;
++        }
++        fn percent_to_val(&mut self, perc: u32) -> u32 {
++                return ((perc as f64 / 100_f64).powf(4_f64) * self.get_max() as f64).round() as u32;
++        }
++
++       fn set_percent(&mut self, val: u32) -> anyhow::Result<()> {
++                let new = self.percent_to_val(val);
++                self.set_val(new)
++       }
++       fn set_val(&mut self, val: u32) -> anyhow::Result<()> {
++                let curr = val.clamp(0, self.get_max());
++                self.current = Some(curr);
++               let _: String = self.run(("set", &*format!("{curr}")))?;
+                Ok(())
+        }
+ }
+@@ -134,20 +145,18 @@ impl BrightnessBackend for BrightnessCtl {
+ 
+        fn lower(&mut self, by: u32) -> anyhow::Result<()> {
+                let curr = self.get_current();
+-               let max = self.get_max();
+-
+-               let curr = curr * 100 / max;
++                let mut new = self.device.val_to_percent(curr).saturating_sub(by);
++                new = self.device.percent_to_val(new).min(curr.saturating_sub(1));
+ 
+-               self.device.set_percent(curr.saturating_sub(by))
++               self.device.set_val(new)
+        }
+ 
+        fn raise(&mut self, by: u32) -> anyhow::Result<()> {
+                let curr = self.get_current();
+-               let max = self.get_max();
+-
+-               let curr = curr * 100 / max;
++                let mut new = self.device.val_to_percent(curr) + by;
++                new = self.device.percent_to_val(new).max(curr + 1);
+ 
+-               self.device.set_percent(curr + by)
++               self.device.set_val(new)
+        }
+ 
+        fn set(&mut self, val: u32) -> anyhow::Result<()> {
diff --git a/overlays/worktime/worktime/__main__.py b/overlays/worktime/worktime/__main__.py
index 4c623acd..ba6c5ff6 100755
--- a/overlays/worktime/worktime/__main__.py
+++ b/overlays/worktime/worktime/__main__.py
@@ -23,7 +23,7 @@ import argparse
 from copy import deepcopy
 
 import sys
-from sys import stderr
+from sys import stderr, stdout
 
 from tabulate import tabulate
 
@@ -38,6 +38,7 @@ from collections import defaultdict
 
 import jsonpickle
 from hashlib import blake2s
+import json
 
 class TogglAPISection(Enum):
     TOGGL = '/api/v9'
@@ -223,6 +224,7 @@ class Worktime(object):
     leave_budget = dict()
     time_per_day = None
     workdays = None
+    pull_forward = dict()
 
     @staticmethod
     @cache
@@ -390,8 +392,6 @@ class Worktime(object):
               if e.errno != 2:
                   raise e
 
-      pull_forward = dict()
-
       start_day = self.start_date.date()
       end_day = self.end_date.date()
 
@@ -418,15 +418,15 @@ class Worktime(object):
                                   if not d == datetime.strptime(c, date_format).replace(tzinfo=tzlocal()).date(): break
                           else:
                               if d >= self.end_date.date():
-                                  pull_forward[d] = min(timedelta(hours = float(hours)), self.time_per_day(d) - (holidays[d] if d in holidays else timedelta()))
+                                  self.pull_forward[d] = min(timedelta(hours = float(hours)), self.time_per_day(d) - (holidays[d] if d in holidays else timedelta()))
       except IOError as e:
           if e.errno != 2:
               raise e
 
       self.days_to_work = dict()
 
-      if pull_forward:
-          end_day = max(end_day, max(list(pull_forward)))
+      if self.pull_forward:
+          end_day = max(end_day, max(list(self.pull_forward)))
 
       for day in [start_day + timedelta(days = x) for x in range(0, (end_day - start_day).days + 1)]:
           if day.isoweekday() in self.workdays:
@@ -470,17 +470,17 @@ class Worktime(object):
           self.extra_days_to_work[self.now.date()] = timedelta()
 
       self.time_to_work = sum([self.days_to_work[day] for day in self.days_to_work.keys() if day <= self.end_date.date()], timedelta())
-      for day in [d for d in list(pull_forward) if d > self.end_date.date()]:
-          days_forward = set([d for d in self.days_to_work.keys() if d >= self.end_date.date() and d < day and (not d in pull_forward or d == self.end_date.date())])
-          extra_days_forward = set([d for d in self.extra_days_to_work.keys() if d >= self.end_date.date() and d < day and (not d in pull_forward or d == self.end_date.date())])
+      for day in [d for d in list(self.pull_forward) if d > self.end_date.date()]:
+          days_forward = set([d for d in self.days_to_work.keys() if d >= self.end_date.date() and d < day and (not d in self.pull_forward or d == self.end_date.date())])
+          extra_days_forward = set([d for d in self.extra_days_to_work.keys() if d >= self.end_date.date() and d < day and (not d in self.pull_forward or d == self.end_date.date())])
           days_forward = days_forward.union(extra_days_forward)
 
           extra_day_time_left = timedelta()
           for extra_day in extra_days_forward:
               day_time = max(timedelta(), self.time_per_day(extra_day) - self.extra_days_to_work[extra_day])
               extra_day_time_left += day_time
-          extra_day_time = min(extra_day_time_left, pull_forward[day])
-          time_forward = pull_forward[day] - extra_day_time
+          extra_day_time = min(extra_day_time_left, self.pull_forward[day])
+          time_forward = self.pull_forward[day] - extra_day_time
           if extra_day_time_left > timedelta():
             for extra_day in extra_days_forward:
                 day_time = max(timedelta(), self.time_per_day(extra_day) - self.extra_days_to_work[extra_day])
@@ -518,7 +518,14 @@ def format_days(worktime, days, date_format=None):
     return ', '.join(map(lambda group: ','.join(map(format_group, group)), groups))
 
 
-def worktime(pull_forward_cutoff, **args):
+def tooltip_timedelta(td):
+    if td < timedelta(seconds = 0):
+        return "-" + tooltip_timedelta(-td)
+    mm, ss = divmod(td.total_seconds(), 60)
+    hh, mm = divmod(mm, 60)
+    return "%d:%02d:%02d" % (hh, mm, ss)
+
+def worktime(pull_forward_cutoff, waybar, **args):
     worktime = Worktime(**args)
 
     def format_worktime(worktime):
@@ -562,7 +569,12 @@ def worktime(pull_forward_cutoff, **args):
               else:
                   return f"({difference_string})"
 
-    if worktime.time_pulled_forward >= pull_forward_cutoff:
+    out_class = "running" if worktime.running_entry else "stopped"
+    difference = worktime.time_to_work - worktime.time_worked
+    if worktime.running_entry and -min(timedelta(milliseconds=0), difference) > sum(worktime.pull_forward.values(), start=timedelta(milliseconds=0)) or not worktime.running_entry and max(timedelta(milliseconds=0), difference) > worktime.time_per_day(worktime.now.date()) and worktime.now_is_workday:
+        out_class = "over"
+    tooltip = tooltip_timedelta(difference)
+    if worktime.time_pulled_forward >= min(pull_forward_cutoff, timedelta(seconds = 1)):
         worktime_no_pulled_forward = deepcopy(worktime)
         worktime_no_pulled_forward.time_to_work -= worktime_no_pulled_forward.time_pulled_forward
         worktime_no_pulled_forward.time_pulled_forward = timedelta()
@@ -570,11 +582,24 @@ def worktime(pull_forward_cutoff, **args):
         difference_string = format_worktime(worktime)
         difference_string_no_pulled_forward = format_worktime(worktime_no_pulled_forward)
 
-        print(f"{difference_string_no_pulled_forward}…{difference_string}")
+        tooltip = tooltip_timedelta(worktime_no_pulled_forward.time_to_work - worktime_no_pulled_forward.time_worked) + "…" + tooltip
+        if worktime.time_pulled_forward >= pull_forward_cutoff:
+            out_text = f"{difference_string_no_pulled_forward}…{difference_string}"
+        else:
+            out_text = format_worktime(worktime)
+    else:
+        out_text = format_worktime(worktime)
+
+    if waybar:
+        json.dump({"text": out_text, "class": out_class, "tooltip": tooltip}, stdout)
     else:
-        print(format_worktime(worktime))
+        print(out_text)
 
-def time_worked(now, **args):
+def pull_forward(**args):
+    worktime = Worktime(**args)
+    print(tooltip_timedelta(sum(worktime.pull_forward.values(), start=timedelta(milliseconds=0))))
+
+def time_worked(now, waybar, **args):
     then = now.replace(hour = 0, minute = 0, second = 0, microsecond = 0)
     if now.time() == time():
         now = now + timedelta(days = 1)
@@ -584,6 +609,9 @@ def time_worked(now, **args):
 
     worked = now.time_worked - then.time_worked
 
+    out_text = None
+    out_class = "stopped"
+    tooltip = tooltip_timedelta(worked)
     if args['do_round']:
       total_minutes_difference = 5 * ceil(worked / timedelta(minutes = 5))
       (hours_difference, minutes_difference) = divmod(abs(total_minutes_difference), 60)
@@ -602,15 +630,25 @@ def time_worked(now, **args):
           difference = target_time - worked
           clockout_difference = 5 * ceil(difference / timedelta(minutes = 5))
           clockout_time = now.now + difference
+          exact_clockout_time = clockout_time
           clockout_time += (5 - clockout_time.minute % 5) * timedelta(minutes = 1)
           clockout_time = clockout_time.replace(second = 0, microsecond = 0)
 
       if now.running_entry and clockout_time and clockout_difference >= 0:
-          print(f"{difference_string}/{clockout_time:%H:%M}")
+          out_class = "running"
+          out_text = f"{difference_string}/{clockout_time:%H:%M}"
+          tooltip = f"{tooltip_timedelta(worked)}/{exact_clockout_time:%H:%M}"
       else:
-          print(difference_string)
+          if now.running_entry:
+              out_class = "over"
+          out_text = difference_string
+    else:
+      out_text = str(worked)
+
+    if waybar:
+        json.dump({"text": out_text, "class": out_class, "tooltip": tooltip}, stdout)
     else:
-      print(worked)
+        print(out_text)
 
 def diff(now, **args):
     now = now.replace(hour = 0, minute = 0, second = 0, microsecond = 0)
@@ -841,9 +879,11 @@ def main():
     subparsers = parser.add_subparsers(help = 'Subcommands')
     worktime_parser = subparsers.add_parser('time_worked', aliases = ['time', 'worked'])
     worktime_parser.add_argument('--pull-forward-cutoff', dest = 'pull_forward_cutoff', metavar = 'MINUTES', type = duration_minutes, default = timedelta(minutes = 15))
+    worktime_parser.add_argument('--waybar', action='store_true')
     worktime_parser.set_defaults(cmd = worktime)
     time_worked_parser = subparsers.add_parser('today')
     time_worked_parser.add_argument('--no-round', dest = 'do_round', action = 'store_false')
+    time_worked_parser.add_argument('--waybar', action='store_true')
     time_worked_parser.set_defaults(cmd = time_worked)
     diff_parser = subparsers.add_parser('diff')
     diff_parser.set_defaults(cmd = diff)
@@ -861,6 +901,8 @@ def main():
         classification_parser.add_argument('--table', action = 'store_true')
         classification_parser.add_argument('--table-format', dest='table_format', type=str, default='fancy_grid')
         classification_parser.set_defaults(cmd = partial(classification, classification_name=classification_name))
+    pull_forward_parser = subparsers.add_parser('pull-forward')
+    pull_forward_parser.set_defaults(cmd = pull_forward)
     parser.set_default_subparser('time_worked')
     args = parser.parse_args()