3 files changed, 121 insertions, 19 deletions

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()