docs: admit that this is a github project now

Reviewed-on: #20

.gitea/workflows/cargo.yaml

@@ -1,44 +0,0 @@
-name: cargo devel CI
-on:
-  push:
-    branches:
-      - '**'
-      # - '!master'
-
-jobs:
-  format:
-    name: cargo CI
-    permissions:
-      # Give the default GITHUB_TOKEN write permission to commit and push the
-      # added or changed files to the repository.
-      contents: write
-    steps:
-      - name: get repo
-        uses: actions/checkout@v4
-      - name: install rust
-        uses: https://github.com/dtolnay/rust-toolchain@stable
-      - name: install additional rust things
-        run: |
-          rustup component add rustfmt
-          rustup component add clippy
-      - name: config custom registry
-        run: |
-          mkdir -p ~/.cargo/
-          echo "" > ~/.cargo/config.toml
-          echo "[registry]" >> ~/.cargo/config.toml
-          echo 'cscherr = "cscherr"' >> ~/.cargo/config.toml
-          echo '[registries.cscherr]' >> ~/.cargo/config.toml
-          echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
-          cat ~/.cargo/config.toml
-      - name: cargo clippy check
-        run: cargo clippy --all-features --all-targets --workspace
-      - name: cargo clippy fix
-        run: cargo clippy --fix --all-features --all-targets --workspace
-      - name: cargo fmt
-        run: cargo fmt --all
-      - name: commit back to repository
-        uses: https://github.com/stefanzweifel/git-auto-commit-action@v5
-        with:
-          # Optional. Commit message for the created commit.
-          # Defaults to "Apply automatic changes"
-          commit_message: automatic cargo CI changes

.github/dependabot.yaml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    # Check for updates every Monday
+    schedule:
+      interval: "weekly"

.github/workflows/cargo.yaml

@@ -1,10 +1,16 @@
-name: cargo devel CI
+name: Rust CI
 on:
+  pull_request:
+    branches:
+      - '**'
   push:
     branches:
       - '**'
       # - '!master'
 
+env:
+  CARGO_TERM_COLOR: always
+
 jobs:
   CI:
     runs-on: ubuntu-latest
@@ -31,15 +37,19 @@ jobs:
           echo '[registries.cscherr]' >> ~/.cargo/config.toml
           echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
           cat ~/.cargo/config.toml
+      - name: install additional system dependencies
+        run: sudo apt-get install -y libasound2-dev libdbus-1-dev
       - name: cargo clippy check
         run: cargo clippy --all-features --all-targets --workspace
       - name: cargo clippy fix
         run: cargo clippy --fix --all-features --all-targets --workspace
       - name: cargo fmt
         run: cargo fmt --all
+      - name: cargo test
+        run: cargo test --all-features --all-targets --workspace
       - name: commit back to repository
         uses: stefanzweifel/git-auto-commit-action@v5
         with:
           # Optional. Commit message for the created commit.
           # Defaults to "Apply automatic changes"
-          commit_message: automatic cargo CI changes
+          commit_message: "ci: automatic Rust CI changes"

.github/workflows/release.yaml

@@ -0,0 +1,56 @@
+name: Release-plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches:
+      - master
+      - main
+
+jobs:
+
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: install additional system dependencies
+        run: sudo apt-get install -y libasound2-dev libdbus-1-dev
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crock"
-version = "0.1.5"
+version = "0.3.1"
 edition = "2021"
 publish = true
 authors = ["Christoph J. Scherr <software@cscherr.de>"]
@@ -12,10 +12,23 @@ repository = "https://git.cscherr.de/PlexSheep/crock"
 keywords = ["time", "clock", "tui"]
 categories = ["date-and-time"]
 
+[features]
+default = ["desktop", "sound"]
+desktop = ["dep:notify-rust"]
+sound = ["dep:rodio"]
+
 
 [dependencies]
 anyhow = "1.0.86"
 chrono = "0.4.38"
+human-panic = "2.0.0"
+humantime = "2.1.0"
 libpt = { version = "0.6.0", features = ["cli"] }
+notify-rust = { version = "4.11.0", default-features = false, features = [
+	"d",
+], optional = true }
 ratatui = "0.27.0"
+rodio = { version = "0.19.0", optional = true, default-features = false, features = [
+	"mp3",
+] }
 tui-big-text = "0.4.5"

README.md

@@ -2,14 +2,31 @@
 
 ![Project badge](https://img.shields.io/badge/language-Rust-blue.svg)
 ![Crates.io License](https://img.shields.io/crates/l/crock)
-![Gitea Release](https://img.shields.io/gitea/v/release/PlexSheep/crock?gitea_url=https%3A%2F%2Fgit.cscherr.de)
+![GitHub Release](https://img.shields.io/github/v/release/PlexSheep/crock)
-![Gitea language count](https://img.shields.io/gitea/languages/count/PlexSheep/crock?gitea_url=https%3A%2F%2Fgit.cscherr.de)
+![GitHub language count](https://img.shields.io/github/languages/count/PlexSheep/crock)
-[![cargo checks and tests](https://github.com/PlexSheep/crock/actions/workflows/cargo.yaml/badge.svg)](https://github.com/PlexSheep/crock/actions/workflows/cargo.yaml)
+
 
 A little clock for your terminal, written in rust.
 
 ![screenshot](data/media/screenshot.png)
 
-* [Original Repository](https://git.cscherr.de/PlexSheep/crock)
+* [GitHub](https://github.com/PlexSheep/crock)
-* [GitHub Mirror](https://github.com/PlexSheep/crock)
 * [crates.io](https://crates.io/crates/crock)
+
+## Compilation
+
+The `desktop` and `sound` features require additional system dependencies:
+
+| Feature   | Dependency | PKG Name on Debian based Distributions |
+|-----------|------------|----------------------------------------|
+| `desktop` | dbus       | `libdbus-1-dev`                        |
+| `sound`   | alsa       | `libasound2-dev`                       |
+
+If you want to compile without these features, you will not have notifications 
+and sound alerts for countdown mode. (Use `cargo build -r --no-default-features`)
+
+## Acknoledgements
+
+The included alarm sound is from [freesound.org](https://freesound.org):
+
+-> ["effect_notify.wav" by ricemaster (CC-0)](https://freesound.org/people/ricemaster/sounds/278142/)

src/clock.rs

@@ -1,31 +1,229 @@
 #![warn(clippy::pedantic, clippy::style, clippy::nursery)]
+// That's useful and sometimes I don't need extra stuff
 #![allow(clippy::question_mark_used)]
-use clap::Parser;
+// allows us to cast u64 to i64, if the number is too high
-use libpt::cli::{args::VerbosityLevel, args::HELP_TEMPLATE, clap};
+// enough time has passed that I don't care
+#![allow(clippy::cast_possible_wrap)]
+#![allow(clippy::cast_sign_loss)] // it should only be positive anyway
 
-use chrono::SubsecRound;
+use chrono::{DateTime, Local, SubsecRound, Timelike};
+use clap::Parser;
+use libpt::cli::args::HELP_TEMPLATE;
+use libpt::cli::clap::ArgGroup;
+use libpt::cli::{args::VerbosityLevel, clap};
+use libpt::log::{debug, error, trace};
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::event::{self, poll, Event, KeyCode, KeyModifiers};
 use ratatui::layout::{Alignment, Constraint, Direction, Layout, Rect};
 use ratatui::style::{Style, Stylize};
 use ratatui::widgets::{Block, Padding, Paragraph};
 use ratatui::Terminal;
-use std::io::Stdout;
+use std::collections::HashMap;
-use std::time::Duration;
+use std::io::{Cursor, Stdout, Write};
+use std::time::Instant;
+
+pub mod timebar;
+pub mod ui;
+use timebar::TimeBarLength;
+use ui::Data;
 
 /// Make your terminal into a big clock
-#[derive(Parser, Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Parser, Debug, Clone)]
 #[command(help_template = HELP_TEMPLATE, author, version)]
+#[clap(group( ArgGroup::new("timebarlen") .args(&["minute","day", "hour", "custom", "countdown", "timer"]),))]
+#[allow(clippy::struct_excessive_bools)] // the struct is for cli parsing and we already use an
+                                         // ArgGroup
 pub struct Clock {
     #[command(flatten)]
     pub verbose: VerbosityLevel,
+    /// Show time since start
+    #[clap(short, long)]
+    pub timer: bool,
+
+    // timebar options
+    /// show a time bar that tracks progress of the minute
+    #[clap(short, long)]
+    pub minute: bool,
+    /// show a time bar that tracks progress of the day
+    #[clap(short, long)]
+    pub day: bool,
+    /// show a time bar that tracks progress of the hour
+    #[clap(short = 'o', long)]
+    pub hour: bool,
+    /// show a time bar that tracks progress of a custom duration
+    ///
+    /// Precision: only to seconds
+    #[clap(short, long, value_parser = humantime::parse_duration)]
+    pub custom: Option<std::time::Duration>,
+    /// show a time bar that tracks progress of a custom duration without resetting
+    ///
+    /// Precision: only to seconds
+    #[clap(short = 'u', long, value_parser = humantime::parse_duration)]
+    pub countdown: Option<std::time::Duration>,
+    /// Play a notification sound when the countdown is up
+    #[cfg(feature = "sound")]
+    #[clap(short, long, default_value_t = true)]
+    pub sound: bool,
+
+    // internal variables
+    #[clap(skip)]
+    pub(crate) last_reset: Option<DateTime<Local>>,
+    #[clap(skip)]
+    pub(crate) did_notify: bool,
 }
 
 impl Clock {
+    #[must_use]
+    #[allow(clippy::missing_const_for_fn)]
+    fn timebar_len(&self) -> Option<TimeBarLength> {
+        if self.minute {
+            Some(TimeBarLength::Minute)
+        } else if self.day {
+            Some(TimeBarLength::Day)
+        } else if self.hour {
+            Some(TimeBarLength::Hour)
+        } else if self.timer {
+            Some(TimeBarLength::Timer)
+        } else if self.countdown.is_some() {
+            Some(TimeBarLength::Countup(
+                self.countdown.unwrap().as_secs() as i64
+            ))
+        } else if self.custom.is_some() {
+            Some(TimeBarLength::Custom(self.custom.unwrap().as_secs() as i64))
+        } else {
+            None
+        }
+    }
+
+    #[allow(clippy::cast_precision_loss)] // okay, good to know, but I accept the loss. It
+                                          // shouldn't come to more than 2^52 seconds anyway
+    pub(crate) fn timebar_ratio(&self, current_time: DateTime<Local>) -> Option<f64> {
+        let len = self.timebar_len()?;
+        let since = current_time
+            .signed_duration_since(self.last_reset.unwrap())
+            .num_seconds() as f64;
+        #[cfg(debug_assertions)]
+        if since < 1.0 {
+            trace!("ratio calculation since is now <1: {:#?}", since);
+        }
+        Some((since / len.as_secs() as f64).clamp(0.0, 1.0))
+    }
+
+    pub(crate) fn maybe_reset_since_zero(&mut self) {
+        if let Some(len) = self.timebar_len() {
+            let since_last_reset = Local::now().signed_duration_since(self.last_reset.unwrap());
+            match len {
+                TimeBarLength::Countup(_) | TimeBarLength::Timer => {
+                    // the count up should not reset. If the time is over, just keep it at 100%
+                }
+                TimeBarLength::Custom(_) => {
+                    // BUG: this is not consistent, sometimes leads to wrong seconds
+                    if since_last_reset.num_milliseconds() >= 100
+                        && since_last_reset.num_seconds() >= len.as_secs()
+                    {
+                        self.last_reset = Some(Local::now().round_subsecs(0));
+                    }
+                }
+                TimeBarLength::Minute => {
+                    if since_last_reset.num_seconds() >= 1 && Local::now().second() == 0 {
+                        self.last_reset = Some(
+                            Local::now()
+                                .round_subsecs(0)
+                                .with_second(1)
+                                .expect("tried to use a time that does not exist"),
+                        );
+                        debug!("reset the time of the time bar (minute)");
+                    }
+                }
+                TimeBarLength::Hour => {
+                    if since_last_reset.num_minutes() >= 1 && Local::now().minute() == 0 {
+                        self.last_reset = Some(
+                            Local::now()
+                                .round_subsecs(0)
+                                .with_second(1)
+                                .expect("tried to use a time that does not exist"),
+                        );
+                        debug!("reset the time of the time bar (hour)");
+                    }
+                }
+                TimeBarLength::Day => {
+                    if since_last_reset.num_hours() >= 1 && Local::now().hour() == 0 {
+                        self.last_reset = Some(
+                            Local::now()
+                                .round_subsecs(0)
+                                .with_second(1)
+                                .expect("tried to use a time that does not exist"),
+                        );
+                        debug!("reset the time of the time bar (day)");
+                    }
+                }
+            }
+        }
+    }
+
+    fn setup_last_reset(&mut self) {
+        if let Some(len) = self.timebar_len() {
+            trace!("Local Time: {}", Local::now());
+            match len {
+                TimeBarLength::Custom(_) | TimeBarLength::Countup(_) | TimeBarLength::Timer => {
+                    self.last_reset = Some(Local::now());
+                }
+                TimeBarLength::Minute => {
+                    self.last_reset = Some(
+                        Local::now()
+                            .round_subsecs(0)
+                            .with_second(1)
+                            .expect("tried to use a time that does not exist"),
+                    );
+                }
+                TimeBarLength::Hour => {
+                    self.last_reset = Some(
+                        Local::now()
+                            .round_subsecs(0)
+                            .with_second(1)
+                            .expect("tried to use a time that does not exist")
+                            .with_minute(0)
+                            .expect("tried to use a time that does not exist"),
+                    );
+                }
+                TimeBarLength::Day => {
+                    self.last_reset = Some(
+                        Local::now()
+                            .round_subsecs(0)
+                            .with_second(1)
+                            .expect("tried to use a time that does not exist")
+                            .with_minute(0)
+                            .expect("tried to use a time that does not exist")
+                            .with_hour(0)
+                            .expect("tried to use a time that does not exist"),
+                    );
+                }
+            }
+            debug!("set up initial last reset as {:#?}", self.last_reset);
+        }
+    }
+
+    #[allow(clippy::unnecessary_wraps)] // we have that to be future proof
+    pub(crate) fn setup(&mut self) -> anyhow::Result<()> {
+        self.setup_last_reset();
+        Ok(())
+    }
+
+    /// Run the clock TUI
+    ///
+    /// # Errors
+    ///
+    /// * The [setup](Self::setup) fails
+    /// * Drawing the [ui](Self::ui) fails
+    /// * Polling or reading an event fails
     pub(crate) fn run(
-        self,
+        mut self,
         terminal: &mut Terminal<CrosstermBackend<Stdout>>,
     ) -> anyhow::Result<()> {
+        let tick_rate = std::time::Duration::from_millis(100);
+        let mut last_tick = Instant::now();
+        let mut uidata: Data = Data::new(self.timebar_len());
+        self.setup()?;
         loop {
             let raw_time = chrono::Local::now().round_subsecs(0);
             let splits: Vec<String> = raw_time
@@ -34,62 +232,215 @@ impl Clock {
                 .split_whitespace()
                 .map(str::to_string)
                 .collect();
-            let fdate: String = splits[0].clone();
+
-            let ftime: String = splits[1].clone();
+            // We somehow fill timebar_ratio with a bad value here if we don't add 1 second. It's
-            terminal.draw(|frame| {
+            // always the value that would be right for now-1s. The start of the minute is
-                let root = frame.size();
+            // special, with this strategy it is 100%. #10
-                let space = Block::bordered()
+            //
-                    .padding(Padding::new(
+            // If we manually add a second, it works as expected, but it feels weird. We use the
-                        root.width / 8,
+            // same time for all of the datapoints here, so it can't be because of time diff in
-                        root.width / 8,
+            // calculation. I noticed that we don't start at 0% this way (with len=minute)
-                        root.height / 8,
+            // . Normally, chrono does not include 60 seconds, only letting it range between 0 and
-                        root.height / 8,
+            // 59. This makes sense but feels weird to the human understanding, of course there are
-                    ))
+            // seconds in a minute! If we do it this way, we don't quite start at 0%, but 100%,
-                    .title(env!("CARGO_PKG_NAME"))
+            // which feels correct.
-                    .title_bottom(env!("CARGO_PKG_VERSION"))
+            //
-                    .title_alignment(Alignment::Center)
+            // In short: if we add a second here, we get the correct percentages. 01:00 is 100%,
-                    .title_style(Style::new().bold());
+            // 01:30 is 50%, 01:59 is 98%, 01:60 does not exist because that's how counting from
-                let a = space.inner(root);
+            // 0 works.
-                let parts = Self::partition(a);
+
-                let timew = tui_big_text::BigText::builder()
+            let now = raw_time + chrono::Duration::seconds(1);
-                    .style(Style::new().red())
+            uidata.update(
-                    .lines(vec![ftime.into()])
+                now,
-                    .alignment(Alignment::Center)
+                splits[0].clone(),
-                    .build()
+                splits[1].clone(),
-                    .expect("could not render time widget");
+                self.timebar_ratio(now),
-                let datew = Paragraph::new(fdate)
+            );
-                    .blue()
+            if uidata.changed() {
-                    .alignment(Alignment::Left)
+                self.ui(terminal, &uidata)?;
-                    .block(Block::new().padding(Padding::new(
+            }
-                        parts.0.left(),
+            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
-                        parts.0.right() / 3,
+            if poll(timeout)? {
-                        0,
-                        0,
-                    )));
-                frame.render_widget(space, root);
-                frame.render_widget(timew, parts.1);
-                frame.render_widget(datew, parts.0);
-            })?;
-            if poll(Duration::from_millis(100))? {
                 if let Event::Key(key) = event::read()? {
                     if key.code == KeyCode::Char('q')
                         || key.code == KeyCode::Esc
                         || (key.modifiers.contains(KeyModifiers::CONTROL)
                             && key.code == KeyCode::Char('c'))
                     {
-                        break;
+                        return Ok(());
                     }
                 }
             }
+            if last_tick.elapsed() >= tick_rate {
+                self.on_tick();
+                last_tick = Instant::now();
+            }
+        }
+    }
+    fn on_tick(&mut self) {
+        self.maybe_reset_since_zero();
+    }
+    #[allow(clippy::cast_possible_truncation)] // if we have that much padding, please truncate
+    fn ui(
+        &mut self,
+        terminal: &mut Terminal<CrosstermBackend<Stdout>>,
+        data: &Data,
+    ) -> anyhow::Result<()> {
+        terminal.draw(|frame| {
+            debug!("rendering the ui");
+            let root = frame.size();
+            let space = Block::bordered()
+                .padding(Padding::new(
+                    root.width / 16,
+                    root.width / 16,
+                    root.height / 16,
+                    root.height / 16,
+                ))
+                .title(env!("CARGO_PKG_NAME"))
+                .title_bottom(env!("CARGO_PKG_VERSION"))
+                .title_alignment(Alignment::Center)
+                .title_style(Style::new().bold());
+            let inner_rect = space.inner(root);
+            frame.render_widget(space, root);
+            let parts = Self::partition(inner_rect);
+
+            let mut clockw = tui_big_text::BigText::builder();
+            if inner_rect.width > 80 {
+                clockw.pixel_size(tui_big_text::PixelSize::Full);
+            } else {
+                clockw.pixel_size(tui_big_text::PixelSize::Quadrant);
+            }
+
+            let clockw = clockw
+                .style(Style::new().red())
+                .lines(vec![data.ftime().into()])
+                .alignment(Alignment::Center)
+                .build()
+                .expect("could not render time widget");
+
+            // render the timebar which counts up to the full minute and so on
+            //
+            // Will not be rendered if it is None
+            let timebarw_padding = [
+                (f32::from(parts["timebarw"].width) * 0.43) as u16,
+                (f32::from(parts["timebarw"].width) * 0.25) as u16,
+            ];
+            let timebarw = ui::timebarw(self, data, &timebarw_padding, inner_rect);
+            let timebarw_label: Option<Paragraph> =
+                ui::timebarw_label(self, data, &timebarw_padding, inner_rect);
+
+            // render the small date
+            let datew = Paragraph::new(data.fdate())
+                .blue()
+                .block(Block::default().padding(Padding::right(2)))
+                .alignment(Alignment::Right);
+            frame.render_widget(&timebarw, parts["timebarw"]);
+            frame.render_widget(&timebarw_label, parts["timebarw_label"]);
+            frame.render_widget(datew, parts["datew"]);
+            // render the clock
+            frame.render_widget(clockw, parts["clockw"]);
+        })?;
+        debug!("done rendering the ui");
+        Ok(())
+    }
+    fn notify(&mut self) -> anyhow::Result<()> {
+        Self::beep()?;
+        #[cfg(feature = "sound")]
+        if self.sound {
+            std::thread::spawn(|| {
+                use rodio::{Decoder, OutputStream, Sink};
+                // only 30 KiB, so let's just include it in the binary and not worry about reading it
+                // from the fs and somehow making the file be there
+                const SOUND_RAW: &[u8] = include_bytes!("../data/media/alarm.mp3");
+
+                trace!("playing bundled sound");
+
+                let sound_data: Cursor<_> = std::io::Cursor::new(SOUND_RAW);
+
+                let (_stream, stream_handle) = OutputStream::try_default().unwrap();
+                let sink = Sink::try_new(&stream_handle).unwrap();
+                sink.append(
+                    Decoder::new(sound_data).expect("could not decode the bundled alarm sound"),
+                );
+                sink.sleep_until_end();
+
+                debug!("played bundled sound");
+            });
+        }
+        #[cfg(feature = "desktop")]
+        {
+            let mut notify = notify_rust::Notification::new();
+
+            notify.appname(env!("CARGO_BIN_NAME"));
+
+            // see [FreeDesktop Sound Naming Specification](http://0pointer.de/public/sound-naming-spec.html)
+            // a sound exists for our use-case
+            //
+            // NOTE: sadly, notify_rust does not (yet) support KDE plasma, because
+            // they have a weird way of making sounds and notifications in general
+            // work. At least we get a little notification.
+
+            // only play this when we don't use built in sound, this
+            // isn't as consistent
+            #[cfg(not(feature = "sound"))]
+            notify.sound_name("alarm-clock-elapsed");
+
+            // The user sets the time with the expectation to be notified, but it's
+            // not like the moon is crashing into the earth
+            notify.urgency(notify_rust::Urgency::Normal);
+
+            // We don't need to have it be displayed for ever, the TUI shows that the time is up
+            // (100%) already.
+            notify.timeout(notify_rust::Timeout::Default);
+
+            notify.summary(&format!(
+                "Your countdown of {} is up.",
+                humantime::Duration::from(self.countdown.unwrap())
+            ));
+            // NOTE: this will only work on machines with a proper desktop, not
+            // with things like WSL2 or a docker container. Therefore, it is behind
+            // the desktop feature.
+            let _ = notify.show().inspect_err(|e| {
+                error!("could not notify of finished countup: {e}");
+                debug!(": {e:#?}");
+            });
         }
         Ok(())
     }
-    fn partition(r: Rect) -> (Rect, Rect) {
+    fn beep() -> anyhow::Result<()> {
+        print!("\x07");
+        std::io::stdout().flush()?;
+        Ok(())
+    }
+    fn partition(r: Rect) -> HashMap<&'static str, Rect> {
         let part = Layout::default()
             .direction(Direction::Vertical)
-            .constraints([Constraint::Percentage(13), Constraint::Min(0)])
+            .constraints([
+                Constraint::Length(3),
+                Constraint::Length(if r.width > 80 { 8 } else { 5 }),
+            ])
             .split(r);
+        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_possible_truncation)]
+        let hlen_date: u16 = (f32::from(part[1].width) * 0.32) as u16;
+        let subparts = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([
+                Constraint::Length(hlen_date),
+                Constraint::Length(part[0].width - hlen_date),
+            ])
+            .split(part[0]);
 
-        (part[0], part[1])
+        let timebarw_spaces = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Length(1), Constraint::Length(1)])
+            .split(subparts[1]);
+
+        HashMap::from([
+            ("clockw", part[1]),
+            ("timebarw", timebarw_spaces[0]),
+            ("timebarw_label", timebarw_spaces[1]),
+            ("datew", subparts[0]),
+        ])
     }
 }

src/clock/timebar.rs

@@ -0,0 +1,71 @@
+use std::fmt::Display;
+
+use chrono::Duration;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TimeBarLength {
+    Timer,
+    Minute,
+    Hour,
+    Custom(i64),
+    /// implementing a bar that would grow smaller would be weird, so it's a count up instead of
+    /// a countdown
+    Countup(i64),
+    Day,
+}
+
+impl TimeBarLength {
+    pub(crate) const fn as_secs(self) -> i64 {
+        match self {
+            Self::Minute => 60,
+            Self::Day => 24 * 60 * 60,
+            Self::Hour => 60 * 60,
+            Self::Timer => 1,
+            Self::Custom(secs) | Self::Countup(secs) => secs,
+        }
+    }
+}
+
+impl From<TimeBarLength> for chrono::Duration {
+    fn from(value: TimeBarLength) -> Self {
+        Self::new(value.as_secs(), 0).expect("seconds out of bounds, cannot create duration")
+    }
+}
+
+impl Default for TimeBarLength {
+    fn default() -> Self {
+        Self::Minute
+    }
+}
+
+impl Display for TimeBarLength {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if *self == Self::Timer {
+            return write!(f, "");
+        }
+        let buf = match self {
+            Self::Minute => humantime::Duration::from(
+                Duration::minutes(1)
+                    .to_std()
+                    .expect("could not convert chrono time to std time"),
+            ),
+            Self::Hour => humantime::Duration::from(
+                Duration::hours(1)
+                    .to_std()
+                    .expect("could not convert chrono time to std time"),
+            ),
+            Self::Day => humantime::Duration::from(
+                Duration::days(1)
+                    .to_std()
+                    .expect("could not convert chrono time to std time"),
+            ),
+            Self::Custom(secs) | Self::Countup(secs) => humantime::Duration::from(
+                Duration::seconds(*secs)
+                    .to_std()
+                    .expect("could not convert chrono time to std time"),
+            ),
+            Self::Timer => unreachable!(),
+        };
+        write!(f, "{buf}")
+    }
+}

src/clock/ui.rs

@@ -0,0 +1,221 @@
+use chrono::{DateTime, Local, SubsecRound, Timelike};
+use libpt::log::{debug, error, trace};
+use ratatui::layout::{Alignment, Rect};
+use ratatui::style::{Style, Stylize};
+use ratatui::widgets::{Block, LineGauge, Padding, Paragraph};
+
+use crate::clock::timebar::TimeBarLength;
+
+use super::Clock;
+
+pub const TIME_FORMAT: &str = "%H:%M:%S";
+pub const TIME_FORMAT_SHORT: &str = "%H:%M";
+
+// TODO: make this a ringbuffer with a custom struct inside?
+#[derive(Debug, Clone, PartialEq)]
+pub struct Data {
+    now: [DateTime<Local>; 2],
+    fdate: [String; 2],
+    ftime: [String; 2],
+    timebar_ratio: [Option<f64>; 2],
+
+    timebar_type: Option<TimeBarLength>,
+    started_at: DateTime<Local>,
+
+    idx: usize,
+}
+
+impl Data {
+    pub fn new(timebar_type: Option<TimeBarLength>) -> Self {
+        let mut this = Self {
+            now: [DateTime::default(); 2],
+            fdate: [String::new(), String::new()],
+            ftime: [String::new(), String::new()],
+            timebar_ratio: [Option::default(); 2],
+            started_at: Local::now(),
+            idx: usize::default(),
+
+            timebar_type,
+        };
+        this.started_at = this.started_at.round_subsecs(0);
+        this
+    }
+    pub fn update(
+        &mut self,
+        now: DateTime<Local>,
+        fdate: String,
+        ftime: String,
+        timebar_ratio: Option<f64>,
+    ) {
+        self.idx ^= 1;
+        self.now[self.idx] = now;
+        self.fdate[self.idx] = fdate;
+        self.ftime[self.idx] = ftime;
+        self.timebar_ratio[self.idx] = timebar_ratio;
+        #[cfg(debug_assertions)]
+        if self.changed() {
+            trace!("update with change: {:#?}", self);
+        }
+    }
+
+    /// did the data change with the last update?
+    #[must_use]
+    #[inline]
+    pub fn changed(&self) -> bool {
+        //  the timebar ratio is discarded, so that we only render the ui when the time
+        //  (second) changes
+        self.fdate[0] != self.fdate[1] || self.ftime[0] != self.ftime[1]
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn fdate(&self) -> &str {
+        &self.fdate[self.idx]
+    }
+
+    #[must_use]
+    #[inline]
+    pub fn ftime(&self) -> &str {
+        &self.ftime[self.idx]
+    }
+
+    #[must_use]
+    #[inline]
+    #[allow(clippy::missing_const_for_fn)] // why should it be okay to make this const? This is
+                                           // a custom ringbuffer!
+    pub fn now(&self) -> &DateTime<Local> {
+        &self.now[self.idx]
+    }
+
+    #[must_use]
+    #[inline]
+    #[allow(clippy::missing_const_for_fn)] // no it's not const
+    pub fn timebar_ratio(&self) -> Option<f64> {
+        if self.timebar_type.is_some() && self.timebar_type.unwrap() == TimeBarLength::Timer {
+            return Some(0.0);
+        }
+        self.timebar_ratio[self.idx]
+    }
+}
+
+pub fn timebarw<'a>(
+    clock: &mut Clock,
+    data: &Data,
+    timebarw_padding: &[u16],
+    inner_rect: Rect,
+) -> Option<LineGauge<'a>> {
+    if clock.timebar_len().is_some() {
+        debug!("time bar ration: {:?}", data.timebar_ratio());
+        let ratio = data.timebar_ratio().unwrap();
+
+        if !clock.did_notify && (ratio - 1.0).abs() < 0.000_001 {
+            if let Some(TimeBarLength::Countup(_)) = clock.timebar_len() {
+                let _ = clock.notify().inspect_err(|e| {
+                    error!("could not notify: {e}");
+                    debug!("complete error: {e:#?}");
+                });
+                clock.did_notify = true;
+            }
+        }
+
+        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_possible_truncation)]
+        let timebarw = LineGauge::default()
+            .filled_style(if clock.did_notify {
+                Style::default()
+                    .slow_blink()
+                    .bold()
+                    .underlined()
+                    .yellow()
+                    .crossed_out()
+            } else {
+                Style::default().blue()
+            })
+            .unfilled_style(Style::default())
+            .block(
+                Block::default().padding(Padding::right(if inner_rect.width > 80 {
+                    timebarw_padding[0]
+                } else {
+                    timebarw_padding[1]
+                })),
+            )
+            .ratio(ratio);
+        Some(timebarw)
+    } else {
+        None
+    }
+}
+
+pub fn timebarw_label<'a>(
+    clock: &Clock,
+    data: &Data,
+    timebarw_padding: &[u16],
+    inner_rect: Rect,
+) -> Option<Paragraph<'a>> {
+    clock.timebar_len().map(|len| {
+        let last_reset = clock.last_reset.unwrap().round_subsecs(0);
+        let time_now = match clock.timebar_len().unwrap() {
+            TimeBarLength::Countup(secs) => {
+                if clock.did_notify {
+                    humantime::Duration::from(chrono::Duration::seconds(secs).to_std().unwrap())
+                } else {
+                    humantime::Duration::from(
+                        data.now()
+                            .round_subsecs(0)
+                            .signed_duration_since(last_reset)
+                            .to_std()
+                            .unwrap(),
+                    )
+                }
+            }
+            TimeBarLength::Hour => humantime::Duration::from(
+                data.now()
+                    .signed_duration_since(last_reset)
+                    .to_std()
+                    .unwrap(),
+            ),
+            _ => humantime::Duration::from(
+                data.now()
+                    .round_subsecs(0)
+                    .signed_duration_since(last_reset)
+                    .to_std()
+                    .unwrap(),
+            ),
+        };
+        let until = {
+            // we need to cut off the seconds if we're not in custom and countup mode, otherwise,
+            // the timestamp will not be correct. This fixes #17
+            match len {
+                TimeBarLength::Custom(_) | TimeBarLength::Countup(_) => last_reset,
+                _ => last_reset.with_second(0).unwrap(),
+            }
+        }
+        // BUG: seconds are sometimes a little too much, for
+        // example with `-o` #17
+        .checked_add_signed(len.into())
+        .expect("could not calculate when the countdown finishes")
+        .format(TIME_FORMAT_SHORT);
+
+        let text: String = match clock.timebar_len().unwrap() {
+            TimeBarLength::Timer => format!("{} + {time_now}", data.started_at.format(TIME_FORMAT)),
+            TimeBarLength::Countup(_) | TimeBarLength::Custom(_) => format!(
+                "{time_now} / {len} | {} -> {until}",
+                last_reset.format(TIME_FORMAT_SHORT)
+            ),
+            _ => format!(
+                "{time_now} / {len} | {} -> {until}",
+                last_reset.with_second(0).unwrap().format(TIME_FORMAT_SHORT)
+            ),
+        };
+
+        Paragraph::new(text)
+            .alignment(Alignment::Center)
+            .block(
+                Block::default().padding(Padding::right(if inner_rect.width > 80 {
+                    timebarw_padding[0]
+                } else {
+                    timebarw_padding[1]
+                })),
+            )
+    })
+}

src/main.rs

@@ -1,6 +1,9 @@
+#![allow(missing_docs)] // this is not a library crate
+
 use std::io;
 
 use libpt::cli::clap::Parser;
+use libpt::log::{debug, Level, Logger};
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::event::{DisableMouseCapture, EnableMouseCapture};
 use ratatui::crossterm::execute;
@@ -14,9 +17,31 @@ use self::clock::Clock;
 mod clock;
 
 fn main() -> anyhow::Result<()> {
+    human_panic::setup_panic!(human_panic::Metadata::new(
+        env!("CARGO_BIN_NAME"),
+        env!("CARGO_PKG_VERSION")
+    )
+    .authors(env!("CARGO_PKG_AUTHORS"))
+    .homepage(env!("CARGO_PKG_HOMEPAGE")));
+
     // setup the cli
     let clock = Clock::parse();
+    if clock.verbose.level() >= Level::DEBUG {
+        let _logger = Logger::builder()
+            .log_to_file(true)
+            .log_dir("/tmp/crock/".into())
+            .set_level(clock.verbose.level())
+            .display_time(true)
+            .build()?;
+    } else {
+        // no logger
+    }
+    debug!("set up logger");
 
+    #[cfg(debug_assertions)]
+    mock_tests();
+
+    debug!("taking over terminal");
     // setup terminal
     enable_raw_mode()?;
     let mut stdout = io::stdout();
@@ -24,8 +49,10 @@ fn main() -> anyhow::Result<()> {
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
+    debug!("entering clock");
     let result = clock.run(&mut terminal);
 
+    debug!("restoring terminal");
     // restore terminal
     disable_raw_mode()?;
     execute!(
@@ -35,5 +62,42 @@ fn main() -> anyhow::Result<()> {
     )?;
     terminal.show_cursor()?;
 
+    debug!("done");
     result
 }
+
+#[cfg(debug_assertions)]
+#[allow(clippy::cast_precision_loss)]
+fn mock_tests() {
+    use chrono::{Local, Timelike};
+    use libpt::log::info;
+
+    use crate::clock::ui::Data;
+    info!("doing the mock tests");
+    {
+        let mut c = Clock::parse_from(["some exec", "-mvvv"]);
+        let now = Local::now();
+        c.last_reset = Some(now.with_second(0).unwrap());
+
+        assert_eq!(c.timebar_ratio(now.with_second(30).unwrap()), Some(0.5));
+        info!("30s=0.5");
+        assert_eq!(
+            c.timebar_ratio(now.with_second(59).unwrap()),
+            Some(0.9833333333333333)
+        );
+        info!("60s=1.0");
+        assert_eq!(c.timebar_ratio(now.with_second(0).unwrap()), Some(0.0));
+        info!("0s=0.0");
+    }
+    {
+        let mut data = Data::new(None);
+        let now = Local::now();
+        data.update(now, "date".to_owned(), "time".to_owned(), Some(0.1));
+        assert_eq!(data.timebar_ratio(), Some(0.1));
+        data.update(now, "date".to_owned(), "time".to_owned(), Some(0.2));
+        assert_eq!(data.timebar_ratio(), Some(0.2));
+        data.update(now, "date".to_owned(), "time".to_owned(), Some(0.3));
+        assert_eq!(data.timebar_ratio(), Some(0.3));
+    }
+    info!("finished the mock tests");
+}