Update README

Rust 1.86.0 (#73 )
fix(countdown): reset MET while editing by local time (#72 )
2025-04-17 08:31:40 +02:00 · 2025-04-13 21:37:47 +02:00 · 2025-04-13 21:17:56 +02:00 · 2025-04-13 19:19:46 +02:00 · 2025-03-03 12:21:17 +01:00 · 2025-02-26 14:58:54 +01:00
31 changed files with 2330 additions and 456 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,6 @@ result/**/*
 #.idea/
 #
 .direnv
+
+# ignore (possible) sound files
+**/*.{mp3,wav}
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@@ -1 +1,2 @@
+style_edition = "2024"
 reorder_imports = true
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -1,30 +0,0 @@
-// Folder-specific settings
-//
-// For a full list of overridable settings, and general information on folder-specific settings,
-// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
-{
-  "format_on_save": "on",
-  "formatter": "language_server",
-  "lsp": {
-    "rust-analyzer": {
-      "initialization_options": {
-        "check": {
-          "command": "clippy" // rust-analyzer.check.command (default: "check")
-        }
-      }
-    }
-  },
-  "languages": {
-    "Nix": {
-      "formatter": {
-        "external": {
-          "command": "alejandra",
-          "arguments": [
-            "-q"
-          ]
-        }
-      },
-      "format_on_save": "on"
-    }
-  }
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,48 @@
 # Changelog

+## [Unreleased]
+
+### Fixes
+
+- (countdown) Reset `Mission Elapsed Time (MET)` if `countdown` is set by _cli arguments_ [#71](https://github.com/sectore/timr-tui/pull/71)
+- (countdown) Reset `Mission Elapsed Time (MET)` while setting `countdown` by _local time_ [#72](https://github.com/sectore/timr-tui/pull/72)
+
+### Misc.
+
+- (deps) Use latest `Rust 1.86` [#73](https://github.com/sectore/timr-tui/pull/73)
+- (cargo) Exclude files for packaging [e7a5a1b](https://github.com/sectore/timr-tui/commit/e7a5a1b2da7a7967f2602a0b92f391ac768ca638)
+- (just) `group` commands [#70](https://github.com/sectore/timr-tui/pull/70)
+
+## v1.2.0 - 2025-02-26
+
+### Features
+
+- (notification) Clock animation (blink) by reaching `done` mode (optional) [#65](https://github.com/sectore/timr-tui/pull/65)
+- (notification) Native desktop notification (optional, experimental) [#59](https://github.com/sectore/timr-tui/pull/59)
+- (notification) Sound notification (optional, experimental, available in local build only) [#62](https://github.com/sectore/timr-tui/pull/62)
+- (logging) Add `--log` arg to enable logs [e094d7d](https://github.com/sectore/timr-tui/commit/e094d7d81b99f58f0d3bc50124859a4e1f6dbe4f)
+
+### Misc.
+
+- (refactor) Extend event handling for using a `mpsc` channel to send `AppEvent`'s from anywhere. [#61](https://github.com/sectore/timr-tui/pull/61)
+- (extension) Use `set_panic_hook` for better error handling [#67](https://github.com/sectore/timr-tui/pull/67)
+- (deps) Use latest `Rust 1.85` and `Rust 2024 Edition`. Refactor `flake` to consider `rust-toolchain.toml` etc. [#68](https://github.com/sectore/timr-tui/pull/68)
+
+## v1.1.0 - 2025-01-22
+
+### Features
+
+- (countdown) Edit countdown by local time [#49](https://github.com/sectore/timr-tui/pull/49)
+
+### Fixes
+
+- (ci) Build statically linked binaries for Linux [#55](https://github.com/sectore/timr-tui/pull/55)
+- (ci) Remove magic nix cache action (#57) [#56](https://github.com/sectore/timr-tui/issues/56)
+
+### Misc.
+
+- (deps) Latest Rust 1.84, update deps [#48](https://github.com/sectore/timr-tui/pull/48)
+
 ## v1.0.0 - 2025-01-10

 Happy `v1.0.0` 🎉
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,19 +1,21 @@
 [package]
 name = "timr-tui"
-version = "1.1.0-alpha"
+version = "1.2.0"
 description = "TUI to organize your time: Pomodoro, Countdown, Timer."
-edition = "2021"
-rust-version = "1.84.0"
+edition = "2024"
+# Reminder: Always keep `channel` in `rust-toolchain.toml` in sync with `rust-version`.
+rust-version = "1.86.0"
 homepage = "https://github.com/sectore/timr-tui"
 repository = "https://github.com/sectore/timr-tui"
 readme = "README.md"
 license = "MIT"
 keywords = ["tui", "timer", "countdown", "pomodoro"]
 categories = ["command-line-utilities"]
+exclude = [".github/*", "demo/*.tape", "result/*", "*.mp3"]

 [dependencies]
 ratatui = "0.29.0"
-crossterm = {version = "0.28.1", features = ["event-stream", "serde"] }
+crossterm = { version = "0.28.1", features = ["event-stream", "serde"] }
 color-eyre = "0.6.2"
 futures = "0.3"
 serde = { version = "1", features = ["derive"] }
@@ -27,3 +29,13 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 directories = "5.0.1"
 clap = { version = "4.5.23", features = ["derive"] }
 time = { version = "0.3.37", features = ["formatting", "local-offset"] }
+notify-rust = "4.11.4"
+rodio = { version = "0.20.1", features = [
+    "symphonia-mp3",
+    "symphonia-wav",
+], default-features = false, optional = true }
+thiserror = { version = "2.0.11", optional = true }
+
+
+[features]
+sound = ["dep:rodio", "dep:thiserror"]
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ _Side note:_ Theme colors depend on your terminal preferences.
  <img alt="menu" src="demo/menu.gif" />
 </a>

-## Local time
+## Local time (footer)

 <a href="demo/local-time.gif">
  <img alt="menu" src="demo/local-time.gif" />
@@ -68,18 +68,27 @@ timr-tui --help
 Usage: timr-tui [OPTIONS]

 Options:
-  -c, --countdown <COUNTDOWN>  Countdown time to start from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss' [default: 10:00]
-  -w, --work <WORK>            Work time to count down from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss' [default: 25:00]
-  -p, --pause <PAUSE>          Pause time to count down from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss' [default: 5:00]
-  -d, --decis                  Wether to show deciseconds or not. [default: false]
-  -m, --mode <MODE>            Mode to start with. [possible values: countdown, timer, pomodoro] [default: timer]
-      --menu                   Whether to open the menu or not.
-  -s, --style <STYLE>          Style to display time with. [possible values: full, light, medium, dark, thick, cross, braille] [default: full]
-  -r, --reset                  Reset stored values to default.
+  -c, --countdown <COUNTDOWN>        Countdown time to start from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss'
+  -w, --work <WORK>                  Work time to count down from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss'
+  -p, --pause <PAUSE>                Pause time to count down from. Formats: 'ss', 'mm:ss', or 'hh:mm:ss'
+  -d, --decis                        Show deciseconds.
+  -m, --mode <MODE>                  Mode to start with. [possible values: countdown, timer, pomodoro]
+  -s, --style <STYLE>                Style to display time with. [possible values: full, light, medium, dark, thick, cross, braille]
+      --menu                         Open the menu.
+  -r, --reset                        Reset stored values to default values.
+  -n, --notification <NOTIFICATION>  Toggle desktop notifications. Experimental. [possible values: on, off]
+      --blink <BLINK>                Toggle blink mode to animate a clock when it reaches its finished mode. [possible values: on, off]
+      --log [<LOG>]                  Directory to store log file. If not set, standard application log directory is used (check README for details).
  -h, --help                         Print help
  -V, --version                      Print version
 ```

+Extra option (if `--features sound` is enabled by local build only):
+
+```sh
+--sound <SOUND>                Path to sound file (.mp3 or .wav) to play as notification. Experimental.
+```
+
 # Installation

 ## Cargo
@@ -104,12 +113,10 @@ Install [from the AUR](https://aur.archlinux.org/packages/timr/):
 paru -S timr
 ```

-
 ## Release binaries

 Pre-built artifacts are available to download from [latest GitHub release](https://github.com/sectore/timr-tui/releases).

-
 # Development

 ## Requirements
@@ -120,7 +127,6 @@ Pre-built artifacts are available to download from [latest GitHub release](https

 If you have [`direnv`](https://direnv.net) installed, run `direnv allow` once to install dependencies. In other case run `nix develop`.

-
 ### Non Nix users

 - [`Rust`](https://www.rust-lang.org/learn/get-started)
@@ -131,34 +137,62 @@ If you have [`direnv`](https://direnv.net) installed, run `direnv allow` once to
 ### Commands

 ```sh
-just --list
+just

 Available recipes:
-    build   # build app
-    b       # alias for `build`
-    default
-    format  # format files
-    f       # alias for `format`
-    lint    # lint
-    l       # alias for `lint`
-    run     # run app
-    r       # alias for `run`
-    test    # run tests
-    t       # alias for `test`
+    default               # list commands
+
+    [build]
+    build                 # build app [alias: b]
+
+    [demo]
+    demo-blink            # build demo: blink animation [alias: db]
+    demo-countdown        # build demo: countdown [alias: dc]
+    demo-countdown-met    # build demo: countdown + met [alias: dcm]
+    demo-decis            # build demo: deciseconds [alias: dd]
+    demo-local-time       # build demo: local time [alias: dlt]
+    demo-menu             # build demo: menu [alias: dm]
+    demo-pomodoro         # build demo: pomodoro [alias: dp]
+    demo-rocket-countdown # build demo: rocket countdown [alias: drc]
+    demo-style            # build demo: styles [alias: ds]
+    demo-timer            # build demo: timer [alias: dt]
+
+    [dev]
+    run                      # run app [alias: r]
+    run-args args            # run app with arguments. It expects arguments as a string (e.g. "-c 5:00"). [alias: ra]
+    run-sound path           # run app while sound feature is enabled. It expects a path to a sound file. [alias: rs]
+    run-sound-args path args # run app while sound feature is enabled by adding a path to a sound file and other arguments as string (e.g. "-c 5:00"). [alias: rsa]
+
+    [misc]
+    format                # format files [alias: f]
+    lint                  # lint [alias: l]
+
+    [test]
+    test                  # run tests [alias: t]
 ```

 ### Build

 - Linux
+
 ```sh
 nix build
+# or for bulding w/ statically linked binaries
+nix build .#linuxStatic
 ```

 - Windows (cross-compilation)
+
 ```sh
 nix build .#windows
 ```

+### Run tests
+
+```sh
+cargo test
+```
+
 # Misc.

 ## Persistant app state
@@ -176,7 +210,9 @@ C:/Users/{user}/AppData/Local/timr-tui/data/app.data

 ## Logs

-In `debug` mode only. Locations:
+To get log output, start the app by passing `--log` to `timr-tui`. See [CLI](./#cli) for details.
+
+Logs will be stored in an `app.log` file at following locations:

 ```sh
 # Linux
@@ -186,3 +222,5 @@ In `debug` mode only. Locations:
 # `Windows`
 C:/Users/{user}/AppData/Local/timr-tui/logs/app.log
 ```
+
+Optional: You can use a custom directory by passing it via `--log` arg.
--- a/demo/blink.gif
+++ b/demo/blink.gif
--- a/demo/blink.tape
+++ b/demo/blink.tape
@@ -0,0 +1,23 @@
+Output demo/blink.gif
+
+# https://github.com/charmbracelet/vhs/blob/main/THEMES.md
+Set Theme "nord-light"
+
+Set FontSize 14
+Set Width 800
+Set Height 400
+Set Padding 0
+Set Margin 1
+
+# --- START ---
+Set LoopOffset 4
+Hide
+# countdown 1.0s
+Type "cargo run -- -r -m countdown -d -c 1 --blink=on"
+Enter
+Sleep 0.2
+Type "m"
+Type ":::"
+Show
+Type "s"
+Sleep 4
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "crane": {
      "locked": {
-        "lastModified": 1736566337,
-        "narHash": "sha256-SC0eDcZPqISVt6R0UfGPyQLrI0+BppjjtQ3wcSlk0oI=",
+        "lastModified": 1744386647,
+        "narHash": "sha256-DXwQEJllxpYeVOiSlBhQuGjfvkoGHTtILLYO2FvcyzQ=",
        "owner": "ipetkov",
        "repo": "crane",
-        "rev": "9172acc1ee6c7e1cbafc3044ff850c568c75a5a3",
+        "rev": "d02c1cdd7ec539699aa44e6ff912e15535969803",
        "type": "github"
      },
      "original": {
@@ -23,11 +23,11 @@
        "rust-analyzer-src": "rust-analyzer-src"
      },
      "locked": {
-        "lastModified": 1736577158,
-        "narHash": "sha256-ngnAENZ+vmzOFgnj0EDtHj22nuH7MQB+EqzUmdbvaqA=",
+        "lastModified": 1744231114,
+        "narHash": "sha256-60gLl2rJFt6SRwqWimsTAeHgfsIE1iV0zChdJFOvx8w=",
        "owner": "nix-community",
        "repo": "fenix",
-        "rev": "05dcdb02ea657f81b13d99bd0ca36b09d25f4c43",
+        "rev": "0ccfe532b1433da8e5a23cd513ff6847e0f6a8c2",
        "type": "github"
      },
      "original": {
@@ -56,11 +56,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1736344531,
-        "narHash": "sha256-8YVQ9ZbSfuUk2bUf2KRj60NRraLPKPS0Q4QFTbc+c2c=",
+        "lastModified": 1744463964,
+        "narHash": "sha256-LWqduOgLHCFxiTNYi3Uj5Lgz0SR+Xhw3kr/3Xd0GPTM=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "bffc22eb12172e6db3c5dde9e3e5628f8e3e7912",
+        "rev": "2631b0b7abcea6e640ce31cd78ea58910d31e650",
        "type": "github"
      },
      "original": {
@@ -81,11 +81,11 @@
    "rust-analyzer-src": {
      "flake": false,
      "locked": {
-        "lastModified": 1736517563,
-        "narHash": "sha256-YJ5ajpMsyXITc91ZfnI0Mdocd+tmCFkZ3BLozUkB44M=",
+        "lastModified": 1742296961,
+        "narHash": "sha256-gCpvEQOrugHWLimD1wTFOJHagnSEP6VYBDspq96Idu0=",
        "owner": "rust-lang",
        "repo": "rust-analyzer",
-        "rev": "4f35021ca9a8e7f9ed4344139b9eaf770a2e5725",
+        "rev": "15d87419f1a123d8f888d608129c3ce3ff8f13d4",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@@ -18,31 +18,32 @@
  }:
    flake-utils.lib.eachDefaultSystem (system: let
      pkgs = nixpkgs.legacyPackages.${system};
-      toolchain = with fenix.packages.${system};
-        combine [
-          minimal.rustc
-          minimal.cargo
-          targets.x86_64-pc-windows-gnu.latest.rust-std
-          targets.x86_64-unknown-linux-musl.latest.rust-std
-        ];
+
+      toolchain =
+        fenix.packages.${system}.fromToolchainFile
+        {
+          file = ./rust-toolchain.toml;
+          # sha256 = nixpkgs.lib.fakeSha256;
+          sha256 = "sha256-X/4ZBHO3iW0fOenQ3foEvscgAPJYl2abspaBThDOukI=";
+        };
+
      craneLib = (crane.mkLib pkgs).overrideToolchain toolchain;

-      # Common build inputs for both native and cross compilation
      commonArgs = {
        src = craneLib.cleanCargoSource ./.;
-        cargoArtifacts = craneLib.buildDepsOnly {
-          src = craneLib.cleanCargoSource ./.;
-        };
        strictDeps = true;
        doCheck = false; # skip tests during nix build
      };

+      cargoArtifacts = craneLib.buildDepsOnly commonArgs;
+
      # Native build
      timr = craneLib.buildPackage commonArgs;

      # Linux build w/ statically linked binaries
      staticLinuxBuild = craneLib.buildPackage (commonArgs
        // {
+          inherit cargoArtifacts;
          CARGO_BUILD_TARGET = "x86_64-unknown-linux-musl";
          CARGO_BUILD_RUSTFLAGS = "-C target-feature=+crt-static";
        });
@@ -75,21 +76,28 @@
        windows = windowsBuild;
      };

-      # Development shell with all necessary tools
-      devShell = with nixpkgs.legacyPackages.${system};
-        mkShell {
-          buildInputs = with fenix.packages.${system}.stable; [
-            rust-analyzer
-            clippy
-            rustfmt
+      devShells.default = with nixpkgs.legacyPackages.${system};
+        craneLib.devShell {
+          packages =
+            [
              toolchain
              pkgs.just
              pkgs.nixd
              pkgs.alejandra
+            ]
+            # some extra pkgs needed to play sound on Linux
+            ++ lib.optionals stdenv.isLinux [
+              pkgs.pkg-config
+              pkgs.alsa-lib.dev
+              pkgs.pipewire
            ];

          inherit (commonArgs) src;
-          RUST_SRC_PATH = "${toolchain}/lib/rustlib/src/rust/library";
+
+          ALSA_PLUGIN_DIR =
+            if stdenv.isLinux
+            then "${pkgs.pipewire}/lib/alsa-lib/"
+            else "";
        };
    });
 }
--- a/64
+++ b/64
@@ -2,79 +2,135 @@

 set unstable := true

+# list commands
 default:
    @just --list

 alias b := build
-alias f := format
-alias l := lint
-alias t := test
-alias r := run

 # build app
+[group('build')]
 build:
    cargo build

+alias t := test
+
 # run tests
+[group('test')]
 test:
    cargo test

+alias f := format
+
 # format files
+[group('misc')]
 format:
    just --fmt
    cargo fmt

+alias l := lint
+
 # lint
+[group('misc')]
 lint:
    cargo clippy --no-deps

+alias r := run
+
 # run app
+[group('dev')]
 run:
    cargo run

+alias ra := run-args
+
+# run app with arguments. It expects arguments as a string (e.g. "-c 5:00").
+[group('dev')]
+run-args args:
+    cargo run -- {{ args }}
+
+alias rs := run-sound
+
+# run app while sound feature is enabled. It expects a path to a sound file.
+[group('dev')]
+run-sound path:
+    cargo run --features sound -- --sound={{ path }}
+
+alias rsa := run-sound-args
+
+# run app while sound feature is enabled by adding a path to a sound file and other arguments as string (e.g. "-c 5:00").
+[group('dev')]
+run-sound-args path args:
+    cargo run --features sound -- --sound={{ path }} {{ args }}
+
 # demos

 alias dp := demo-pomodoro

+# build demo: pomodoro
+[group('demo')]
 demo-pomodoro:
    vhs demo/pomodoro.tape

 alias dt := demo-timer

+# build demo: timer
+[group('demo')]
 demo-timer:
    vhs demo/timer.tape

 alias dc := demo-countdown

+# build demo: countdown
+[group('demo')]
 demo-countdown:
    vhs demo/countdown.tape

 alias dcm := demo-countdown-met

+# build demo: countdown + met
+[group('demo')]
 demo-countdown-met:
    vhs demo/countdown-met.tape

 alias ds := demo-style

+# build demo: styles
+[group('demo')]
 demo-style:
    vhs demo/style.tape

 alias dd := demo-decis

+# build demo: deciseconds
+[group('demo')]
 demo-decis:
    vhs demo/decis.tape

 alias dm := demo-menu

+# build demo: menu
+[group('demo')]
 demo-menu:
    vhs demo/menu.tape

 alias dlt := demo-local-time

+# build demo: local time
+[group('demo')]
 demo-local-time:
    vhs demo/local-time.tape

 alias drc := demo-rocket-countdown

+# build demo: rocket countdown
+[group('demo')]
 demo-rocket-countdown:
    vhs demo/met.tape
+
+alias db := demo-blink
+
+# build demo: blink animation
+[group('demo')]
+demo-blink:
+    vhs demo/blink.tape
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -0,0 +1,6 @@
+[toolchain]
+# Reminder: Always keep `rust-version` in `Cargo.toml` in sync with `channel`.
+channel = "1.86.0"
+components = ["clippy", "rustfmt", "rust-src", "rust-analyzer"]
+targets = ["x86_64-pc-windows-gnu", "x86_64-unknown-linux-musl"]
+profile = "minimal"
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,19 +1,23 @@
 use crate::{
    args::Args,
-    common::{AppEditMode, AppTime, AppTimeFormat, Content, Style},
+    common::{AppEditMode, AppTime, AppTimeFormat, ClockTypeId, Content, Style, Toggle},
    constants::TICK_VALUE_MS,
-    events::{Event, EventHandler, Events},
+    events::{self, TuiEventHandler},
    storage::AppStorage,
    terminal::Terminal,
    widgets::{
        clock::{self, ClockState, ClockStateArgs},
-        countdown::{Countdown, CountdownState},
+        countdown::{Countdown, CountdownState, CountdownStateArgs},
        footer::{Footer, FooterState},
        header::Header,
        pomodoro::{Mode as PomodoroMode, PomodoroState, PomodoroStateArgs, PomodoroWidget},
        timer::{Timer, TimerState},
    },
 };
+
+#[cfg(feature = "sound")]
+use crate::sound::Sound;
+
 use color_eyre::Result;
 use ratatui::{
    buffer::Buffer,
@@ -21,9 +25,10 @@ use ratatui::{
    layout::{Constraint, Layout, Rect},
    widgets::{StatefulWidget, Widget},
 };
+use std::path::PathBuf;
 use std::time::Duration;
 use time::OffsetDateTime;
-use tracing::debug;
+use tracing::{debug, error};

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
@@ -31,10 +36,13 @@ enum Mode {
    Quit,
 }

-#[derive(Debug)]
 pub struct App {
    content: Content,
    mode: Mode,
+    notification: Toggle,
+    blink: Toggle,
+    #[allow(dead_code)] // w/ `--features sound` available only
+    sound_path: Option<PathBuf>,
    app_time: AppTime,
    countdown: CountdownState,
    timer: TimerState,
@@ -47,6 +55,8 @@ pub struct App {
 pub struct AppArgs {
    pub style: Style,
    pub with_decis: bool,
+    pub notification: Toggle,
+    pub blink: Toggle,
    pub show_menu: bool,
    pub app_time_format: AppTimeFormat,
    pub content: Content,
@@ -59,15 +69,27 @@ pub struct AppArgs {
    pub current_value_countdown: Duration,
    pub elapsed_value_countdown: Duration,
    pub current_value_timer: Duration,
+    pub app_tx: events::AppEventTx,
+    pub sound_path: Option<PathBuf>,
 }

-/// Getting `AppArgs` by merging `Args` and `AppStorage`.
-/// `Args` wins btw.
-impl From<(Args, AppStorage)> for AppArgs {
-    fn from((args, stg): (Args, AppStorage)) -> Self {
-        AppArgs {
+pub struct FromAppArgs {
+    pub args: Args,
+    pub stg: AppStorage,
+    pub app_tx: events::AppEventTx,
+}
+
+/// Creates an `App` by merging `Args` and `AppStorage` (`Args` wins)
+/// and adding `AppEventTx`
+impl From<FromAppArgs> for App {
+    fn from(args: FromAppArgs) -> Self {
+        let FromAppArgs { args, stg, app_tx } = args;
+
+        App::new(AppArgs {
            with_decis: args.decis || stg.with_decis,
            show_menu: args.menu || stg.show_menu,
+            notification: args.notification.unwrap_or(stg.notification),
+            blink: args.blink.unwrap_or(stg.blink),
            app_time_format: stg.app_time_format,
            content: args.mode.unwrap_or(stg.content),
            style: args.style.unwrap_or(stg.style),
@@ -81,9 +103,18 @@ impl From<(Args, AppStorage)> for AppArgs {
            initial_value_countdown: args.countdown.unwrap_or(stg.inital_value_countdown),
            // invalidate `current_value_countdown` if an initial value is set via args
            current_value_countdown: args.countdown.unwrap_or(stg.current_value_countdown),
-            elapsed_value_countdown: stg.elapsed_value_countdown,
+            elapsed_value_countdown: match args.countdown {
+                // reset value if countdown is set by arguments
+                Some(_) => Duration::ZERO,
+                None => stg.elapsed_value_countdown,
+            },
            current_value_timer: stg.current_value_timer,
-        }
+            app_tx,
+            #[cfg(feature = "sound")]
+            sound_path: args.sound,
+            #[cfg(not(feature = "sound"))]
+            sound_path: None,
+        })
    }
 }

@@ -111,30 +142,40 @@ impl App {
            content,
            with_decis,
            pomodoro_mode,
+            notification,
+            blink,
+            sound_path,
+            app_tx,
        } = args;
        let app_time = get_app_time();
+
        Self {
            mode: Mode::Running,
+            notification,
+            blink,
+            sound_path,
            content,
            app_time,
            style,
            with_decis,
-            countdown: CountdownState::new(
-                ClockState::<clock::Countdown>::new(ClockStateArgs {
+            countdown: CountdownState::new(CountdownStateArgs {
                initial_value: initial_value_countdown,
                current_value: current_value_countdown,
-                    tick_value: Duration::from_millis(TICK_VALUE_MS),
-                    with_decis,
-                }),
-                elapsed_value_countdown,
+                elapsed_value: elapsed_value_countdown,
                app_time,
-            ),
-            timer: TimerState::new(ClockState::<clock::Timer>::new(ClockStateArgs {
+                with_decis,
+                app_tx: app_tx.clone(),
+            }),
+            timer: TimerState::new(
+                ClockState::<clock::Timer>::new(ClockStateArgs {
                    initial_value: Duration::ZERO,
                    current_value: current_value_timer,
                    tick_value: Duration::from_millis(TICK_VALUE_MS),
                    with_decis,
-            })),
+                    app_tx: Some(app_tx.clone()),
+                })
+                .with_name("Timer".to_owned()),
+            ),
            pomodoro: PomodoroState::new(PomodoroStateArgs {
                mode: pomodoro_mode,
                initial_value_work,
@@ -142,33 +183,111 @@ impl App {
                initial_value_pause,
                current_value_pause,
                with_decis,
+                app_tx: app_tx.clone(),
            }),
            footer: FooterState::new(show_menu, app_time_format),
        }
    }

-    pub async fn run(mut self, mut terminal: Terminal, mut events: Events) -> Result<Self> {
-        while self.is_running() {
-            if let Some(event) = events.next().await {
-                if matches!(event, Event::Tick) {
-                    self.app_time = get_app_time();
-                    self.countdown.set_app_time(self.app_time);
+    pub async fn run(
+        mut self,
+        terminal: &mut Terminal,
+        mut events: events::Events,
+    ) -> Result<Self> {
+        // Closure to handle `KeyEvent`'s
+        let handle_key_event = |app: &mut Self, key: KeyEvent| {
+            debug!("Received key {:?}", key.code);
+            match key.code {
+                KeyCode::Char('q') | KeyCode::Esc => app.mode = Mode::Quit,
+                KeyCode::Char('c') => app.content = Content::Countdown,
+                KeyCode::Char('t') => app.content = Content::Timer,
+                KeyCode::Char('p') => app.content = Content::Pomodoro,
+                // toogle app time format
+                KeyCode::Char(':') => app.footer.toggle_app_time_format(),
+                // toogle menu
+                KeyCode::Char('m') => app.footer.set_show_menu(!app.footer.get_show_menu()),
+                KeyCode::Char(',') => {
+                    app.style = app.style.next();
+                }
+                KeyCode::Char('.') => {
+                    app.with_decis = !app.with_decis;
+                    // update clocks
+                    app.timer.set_with_decis(app.with_decis);
+                    app.countdown.set_with_decis(app.with_decis);
+                    app.pomodoro.set_with_decis(app.with_decis);
+                }
+                KeyCode::Up => app.footer.set_show_menu(true),
+                KeyCode::Down => app.footer.set_show_menu(false),
+                _ => {}
+            };
+        };
+        // Closure to handle `TuiEvent`'s
+        let mut handle_tui_events = |app: &mut Self, event: events::TuiEvent| -> Result<()> {
+            if matches!(event, events::TuiEvent::Tick) {
+                app.app_time = get_app_time();
+                app.countdown.set_app_time(app.app_time);
            }

            // Pipe events into subviews and handle only 'unhandled' events afterwards
-                if let Some(unhandled) = match self.content {
-                    Content::Countdown => self.countdown.update(event.clone()),
-                    Content::Timer => self.timer.update(event.clone()),
-                    Content::Pomodoro => self.pomodoro.update(event.clone()),
+            if let Some(unhandled) = match app.content {
+                Content::Countdown => app.countdown.update(event.clone()),
+                Content::Timer => app.timer.update(event.clone()),
+                Content::Pomodoro => app.pomodoro.update(event.clone()),
            } {
                match unhandled {
-                        Event::Render | Event::Resize => {
-                            self.draw(&mut terminal)?;
+                    events::TuiEvent::Render | events::TuiEvent::Resize => {
+                        app.draw(terminal)?;
                    }
-                        Event::Key(key) => self.handle_key_event(key),
+                    events::TuiEvent::Key(key) => handle_key_event(app, key),
                    _ => {}
                }
            }
+            Ok(())
+        };
+
+        #[allow(unused_variables)] // `app` is used by `--features sound` only
+        // Closure to handle `AppEvent`'s
+        let handle_app_events = |app: &mut Self, event: events::AppEvent| -> Result<()> {
+            match event {
+                events::AppEvent::ClockDone(type_id, name) => {
+                    debug!("AppEvent::ClockDone");
+
+                    if app.notification == Toggle::On {
+                        let msg = match type_id {
+                            ClockTypeId::Timer => {
+                                format!("{name} stopped by reaching its maximum value.")
+                            }
+                            _ => format!("{:?} {name} done!", type_id),
+                        };
+                        // notification
+                        let result = notify_rust::Notification::new()
+                            .summary(&msg.to_uppercase())
+                            .show();
+                        if let Err(err) = result {
+                            error!("on_done {name} error: {err}");
+                        }
+                    };
+
+                    #[cfg(feature = "sound")]
+                    if let Some(path) = app.sound_path.clone() {
+                        _ = Sound::new(path).and_then(|sound| sound.play()).or_else(
+                            |err| -> Result<()> {
+                                error!("Sound error: {:?}", err);
+                                Ok(())
+                            },
+                        );
+                    }
+                }
+            }
+            Ok(())
+        };
+
+        while self.is_running() {
+            if let Some(event) = events.next().await {
+                let _ = match event {
+                    events::Event::Terminal(e) => handle_tui_events(&mut self, e),
+                    events::Event::App(e) => handle_app_events(&mut self, e),
+                };
            }
        }
        Ok(self)
@@ -223,33 +342,6 @@ impl App {
        }
    }

-    fn handle_key_event(&mut self, key: KeyEvent) {
-        debug!("Received key {:?}", key.code);
-        match key.code {
-            KeyCode::Char('q') | KeyCode::Esc => self.mode = Mode::Quit,
-            KeyCode::Char('c') => self.content = Content::Countdown,
-            KeyCode::Char('t') => self.content = Content::Timer,
-            KeyCode::Char('p') => self.content = Content::Pomodoro,
-            // toogle app time format
-            KeyCode::Char(':') => self.footer.toggle_app_time_format(),
-            // toogle menu
-            KeyCode::Char('m') => self.footer.set_show_menu(!self.footer.get_show_menu()),
-            KeyCode::Char(',') => {
-                self.style = self.style.next();
-            }
-            KeyCode::Char('.') => {
-                self.with_decis = !self.with_decis;
-                // update clocks
-                self.timer.set_with_decis(self.with_decis);
-                self.countdown.set_with_decis(self.with_decis);
-                self.pomodoro.set_with_decis(self.with_decis);
-            }
-            KeyCode::Up => self.footer.set_show_menu(true),
-            KeyCode::Down => self.footer.set_show_menu(false),
-            _ => {}
-        };
-    }
-
    fn draw(&mut self, terminal: &mut Terminal) -> Result<()> {
        terminal.draw(|frame| {
            frame.render_stateful_widget(AppWidget, frame.area(), self);
@@ -261,6 +353,8 @@ impl App {
        AppStorage {
            content: self.content,
            show_menu: self.footer.get_show_menu(),
+            notification: self.notification,
+            blink: self.blink,
            app_time_format: *self.footer.app_time_format(),
            style: self.style,
            with_decis: self.with_decis,
@@ -289,14 +383,22 @@ impl AppWidget {
    fn render_content(&self, area: Rect, buf: &mut Buffer, state: &mut App) {
        match state.content {
            Content::Timer => {
-                Timer { style: state.style }.render(area, buf, &mut state.timer);
+                Timer {
+                    style: state.style,
+                    blink: state.blink == Toggle::On,
                }
-            Content::Countdown => {
-                Countdown { style: state.style }.render(area, buf, &mut state.countdown)
+                .render(area, buf, &mut state.timer);
            }
-            Content::Pomodoro => {
-                PomodoroWidget { style: state.style }.render(area, buf, &mut state.pomodoro)
+            Content::Countdown => Countdown {
+                style: state.style,
+                blink: state.blink == Toggle::On,
            }
+            .render(area, buf, &mut state.countdown),
+            Content::Pomodoro => PomodoroWidget {
+                style: state.style,
+                blink: state.blink == Toggle::On,
+            }
+            .render(area, buf, &mut state.pomodoro),
        };
    }
 }
--- a/src/args.rs
+++ b/src/args.rs
@@ -1,10 +1,15 @@
 use crate::{
-    common::{Content, Style},
+    common::{Content, Style, Toggle},
    duration,
 };
+#[cfg(feature = "sound")]
+use crate::{sound, sound::SoundError};
 use clap::Parser;
+use std::path::PathBuf;
 use std::time::Duration;

+pub const LOG_DIRECTORY_DEFAULT_MISSING_VALUE: &str = " "; // empty string
+
 #[derive(Parser)]
 #[command(version)]
 pub struct Args {
@@ -23,7 +28,7 @@ pub struct Args {
    )]
    pub pause: Option<Duration>,

-    #[arg(long, short = 'd', help = "Whether to show deciseconds or not.")]
+    #[arg(long, short = 'd', help = "Show deciseconds.")]
    pub decis: bool,

    #[arg(long, short = 'm', value_enum, help = "Mode to start with.")]
@@ -32,9 +37,55 @@ pub struct Args {
    #[arg(long, short = 's', value_enum, help = "Style to display time with.")]
    pub style: Option<Style>,

-    #[arg(long, value_enum, help = "Whether to open the menu or not.")]
+    #[arg(long, value_enum, help = "Open the menu.")]
    pub menu: bool,

-    #[arg(long, short = 'r', help = "Reset stored values to default.")]
+    #[arg(long, short = 'r', help = "Reset stored values to default values.")]
    pub reset: bool,
+
+    #[arg(
+        long,
+        short,
+        value_enum,
+        help = "Toggle desktop notifications. Experimental."
+    )]
+    pub notification: Option<Toggle>,
+
+    #[arg(
+        long,
+        value_enum,
+        help = "Toggle blink mode to animate a clock when it reaches its finished mode."
+    )]
+    pub blink: Option<Toggle>,
+
+    #[cfg(feature = "sound")]
+    #[arg(
+        long,
+        value_enum,
+        help = "Path to sound file (.mp3 or .wav) to play as notification. Experimental.",
+        value_hint = clap::ValueHint::FilePath,
+        value_parser = sound_file_parser,
+    )]
+    pub sound: Option<PathBuf>,
+
+    #[arg(
+        long,
+        // allows both --log=path and --log path syntax
+        num_args = 0..=1,
+        // Note: If no value is passed, use a " " by default,
+        // this value will be checked later in `main`
+        // to use another (default) log directory instead
+        default_missing_value=LOG_DIRECTORY_DEFAULT_MISSING_VALUE,
+        help = "Directory to store log file. If not set, standard application log directory is used (check README for details).",
+        value_hint = clap::ValueHint::DirPath,
+    )]
+    pub log: Option<PathBuf>,
+}
+
+#[cfg(feature = "sound")]
+/// Custom parser for sound file
+fn sound_file_parser(s: &str) -> Result<PathBuf, SoundError> {
+    let path = PathBuf::from(s);
+    sound::validate_sound_file(&path)?;
+    Ok(path)
 }
--- a/src/common.rs
+++ b/src/common.rs
@@ -1,8 +1,8 @@
 use clap::ValueEnum;
 use ratatui::symbols::shade;
 use serde::{Deserialize, Serialize};
-use time::format_description;
 use time::OffsetDateTime;
+use time::format_description;

 #[derive(
    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Default, Serialize, Deserialize,
@@ -17,6 +17,12 @@ pub enum Content {
    Pomodoro,
 }

+#[derive(Clone, Debug)]
+pub enum ClockTypeId {
+    Countdown,
+    Timer,
+}
+
 #[derive(Debug, Copy, Clone, ValueEnum, Default, Serialize, Deserialize)]
 pub enum Style {
    #[default]
@@ -135,6 +141,15 @@ pub enum AppEditMode {
    Time,
 }

+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum Toggle {
+    #[value(name = "on")]
+    On,
+    #[default]
+    #[value(name = "off")]
+    Off,
+}
+
 #[cfg(test)]
 mod tests {

--- a/src/config.rs
+++ b/src/config.rs
@@ -1,8 +1,9 @@
 use crate::constants::APP_NAME;
-use color_eyre::eyre::{eyre, Result};
+use color_eyre::eyre::{Result, eyre};
 use directories::ProjectDirs;
 use std::fs;
 use std::path::PathBuf;
+
 pub struct Config {
    pub log_dir: PathBuf,
    pub data_dir: PathBuf,
@@ -10,8 +11,11 @@ pub struct Config {

 impl Config {
    pub fn init() -> Result<Self> {
+        // default logs dir
        let log_dir = get_default_state_dir()?.join("logs");
        fs::create_dir_all(&log_dir)?;
+
+        // default data dir
        let data_dir = get_default_state_dir()?.join("data");
        fs::create_dir_all(&data_dir)?;

--- a/src/duration.rs
+++ b/src/duration.rs
@@ -1,6 +1,6 @@
 use color_eyre::{
-    eyre::{ensure, eyre},
    Report,
+    eyre::{ensure, eyre},
 };
 use std::fmt;
 use std::time::Duration;
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,9 +1,11 @@
 use crossterm::event::{Event as CrosstermEvent, EventStream, KeyEvent, KeyEventKind};
 use futures::{Stream, StreamExt};
 use std::{pin::Pin, time::Duration};
+use tokio::sync::mpsc;
 use tokio::time::interval;
-use tokio_stream::{wrappers::IntervalStream, StreamMap};
+use tokio_stream::{StreamMap, wrappers::IntervalStream};

+use crate::common::ClockTypeId;
 use crate::constants::{FPS_VALUE_MS, TICK_VALUE_MS};

 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -12,8 +14,9 @@ enum StreamKey {
    Render,
    Crossterm,
 }
+
 #[derive(Clone, Debug)]
-pub enum Event {
+pub enum TuiEvent {
    Error,
    Tick,
    Render,
@@ -21,8 +24,17 @@ pub enum Event {
    Resize,
 }

+#[derive(Clone, Debug)]
+pub enum AppEvent {
+    ClockDone(ClockTypeId, String),
+}
+
+pub type AppEventTx = mpsc::UnboundedSender<AppEvent>;
+pub type AppEventRx = mpsc::UnboundedReceiver<AppEvent>;
+
 pub struct Events {
-    streams: StreamMap<StreamKey, Pin<Box<dyn Stream<Item = Event>>>>,
+    streams: StreamMap<StreamKey, Pin<Box<dyn Stream<Item = TuiEvent>>>>,
+    app_channel: (AppEventTx, AppEventRx),
 }

 impl Default for Events {
@@ -33,31 +45,46 @@ impl Default for Events {
                (StreamKey::Render, render_stream()),
                (StreamKey::Crossterm, crossterm_stream()),
            ]),
+            app_channel: mpsc::unbounded_channel(),
        }
    }
 }

+pub enum Event {
+    Terminal(TuiEvent),
+    App(AppEvent),
+}
+
 impl Events {
    pub fn new() -> Self {
        Self::default()
    }

    pub async fn next(&mut self) -> Option<Event> {
-        self.streams.next().await.map(|(_, event)| event)
+        let streams = &mut self.streams;
+        let app_rx = &mut self.app_channel.1;
+        tokio::select! {
+            Some((_, event)) = streams.next() => Some(Event::Terminal(event)),
+            Some(app_event) = app_rx.recv() => Some(Event::App(app_event)),
+        }
+    }
+
+    pub fn get_app_event_tx(&self) -> AppEventTx {
+        self.app_channel.0.clone()
    }
 }

-fn tick_stream() -> Pin<Box<dyn Stream<Item = Event>>> {
+fn tick_stream() -> Pin<Box<dyn Stream<Item = TuiEvent>>> {
    let tick_interval = interval(Duration::from_millis(TICK_VALUE_MS));
-    Box::pin(IntervalStream::new(tick_interval).map(|_| Event::Tick))
+    Box::pin(IntervalStream::new(tick_interval).map(|_| TuiEvent::Tick))
 }

-fn render_stream() -> Pin<Box<dyn Stream<Item = Event>>> {
+fn render_stream() -> Pin<Box<dyn Stream<Item = TuiEvent>>> {
    let render_interval = interval(Duration::from_millis(FPS_VALUE_MS));
-    Box::pin(IntervalStream::new(render_interval).map(|_| Event::Render))
+    Box::pin(IntervalStream::new(render_interval).map(|_| TuiEvent::Render))
 }

-fn crossterm_stream() -> Pin<Box<dyn Stream<Item = Event>>> {
+fn crossterm_stream() -> Pin<Box<dyn Stream<Item = TuiEvent>>> {
    Box::pin(
        EventStream::new()
            .fuse()
@@ -65,16 +92,16 @@ fn crossterm_stream() -> Pin<Box<dyn Stream<Item = Event>>> {
            .filter_map(|event| async move {
                match event {
                    Ok(CrosstermEvent::Key(key)) if key.kind == KeyEventKind::Press => {
-                        Some(Event::Key(key))
+                        Some(TuiEvent::Key(key))
                    }
-                    Ok(CrosstermEvent::Resize(_, _)) => Some(Event::Resize),
-                    Err(_) => Some(Event::Error),
+                    Ok(CrosstermEvent::Resize(_, _)) => Some(TuiEvent::Resize),
+                    Err(_) => Some(TuiEvent::Error),
                    _ => None,
                }
            }),
    )
 }

-pub trait EventHandler {
-    fn update(&mut self, _: Event) -> Option<Event>;
+pub trait TuiEventHandler {
+    fn update(&mut self, _: TuiEvent) -> Option<TuiEvent>;
 }
--- a/src/logging.rs
+++ b/src/logging.rs
@@ -1,4 +1,4 @@
-use color_eyre::eyre::Result;
+use color_eyre::eyre::{Result, eyre};
 use std::fs;
 use std::path::PathBuf;
 use tracing::level_filters::LevelFilter;
@@ -17,7 +17,13 @@ impl Logger {

    pub fn init(&self) -> Result<()> {
        let log_path = self.log_dir.join("app.log");
-        let log_file = fs::File::create(log_path)?;
+        let log_file = fs::File::create(log_path).map_err(|err| {
+            eyre!(
+                "Could not create a log file in {:?} : {}",
+                self.log_dir,
+                err
+            )
+        })?;
        let fmt_layer = tracing_subscriber::fmt::layer()
            .with_file(true)
            .with_line_number(true)
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,6 @@ mod common;
 mod config;
 mod constants;
 mod events;
-#[cfg(debug_assertions)]
 mod logging;

 mod args;
@@ -13,24 +12,50 @@ mod terminal;
 mod utils;
 mod widgets;

-use app::{App, AppArgs};
-use args::Args;
+#[cfg(feature = "sound")]
+mod sound;
+
+use app::{App, FromAppArgs};
+use args::{Args, LOG_DIRECTORY_DEFAULT_MISSING_VALUE};
 use clap::Parser;
 use color_eyre::Result;
 use config::Config;
+use std::path::PathBuf;
 use storage::{AppStorage, Storage};

 #[tokio::main]
 async fn main() -> Result<()> {
+    // init `Config`
    let cfg = Config::init()?;
-    #[cfg(debug_assertions)]
-    logging::Logger::new(cfg.log_dir).init()?;

    color_eyre::install()?;
+
    // get args given by CLI
    let args = Args::parse();
+    // Note:
+    // `log` arg can have three different values:
+    // (1) not set => None
+    // (2) set with path => Some(Some(path))
+    // (3) set without path => Some(None)
+    let custom_log_dir: Option<Option<&PathBuf>> = if let Some(path) = &args.log {
+        if path.ne(PathBuf::from(LOG_DIRECTORY_DEFAULT_MISSING_VALUE).as_os_str()) {
+            // (2)
+            Some(Some(path))
+        } else {
+            // (3)
+            Some(None)
+        }
+    } else {
+        // (1)
+        None
+    };

-    let terminal = terminal::setup()?;
+    if let Some(log_dir) = custom_log_dir {
+        let dir: PathBuf = log_dir.unwrap_or(&cfg.log_dir).to_path_buf();
+        logging::Logger::new(dir).init()?;
+    }
+
+    let mut terminal = terminal::setup()?;
    let events = events::Events::new();

    // check persistant storage
@@ -42,9 +67,14 @@ async fn main() -> Result<()> {
        storage.load().unwrap_or_default()
    };

-    // merge `Args` and `AppStorage`.
-    let app_args = AppArgs::from((args, stg));
-    let app_storage = App::new(app_args).run(terminal, events).await?.to_storage();
+    let app_storage = App::from(FromAppArgs {
+        args,
+        stg,
+        app_tx: events.get_app_event_tx(),
+    })
+    .run(&mut terminal, events)
+    .await?
+    .to_storage();
    // store app state persistantly
    storage.save(app_storage)?;

--- a/src/sound.rs
+++ b/src/sound.rs
@@ -0,0 +1,73 @@
+use rodio::{Decoder, OutputStream, Sink};
+use std::fs::File;
+use std::io::BufReader;
+use std::path::PathBuf;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum SoundError {
+    #[error("Sound output stream error: {0}")]
+    OutputStream(String),
+    #[error("Sound file error: {0}")]
+    File(String),
+    #[error("Sound sink error: {0}")]
+    Sink(String),
+    #[error("Sound decoder error: {0}")]
+    Decoder(String),
+}
+
+pub fn validate_sound_file(path: &PathBuf) -> Result<&PathBuf, SoundError> {
+    // validate path
+    if !path.exists() {
+        let err = SoundError::File(format!("File not found: {:?}", path));
+        return Err(err);
+    };
+
+    // Validate file extension
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .filter(|ext| ["mp3", "wav"].contains(&ext.to_lowercase().as_str()))
+        .ok_or_else(|| {
+            SoundError::File(
+                "Unsupported file extension. Only .mp3 and .wav are supported".to_owned(),
+            )
+        })?;
+
+    Ok(path)
+}
+
+// #[derive(Clone)]
+pub struct Sound {
+    path: PathBuf,
+}
+
+impl Sound {
+    pub fn new(path: PathBuf) -> Result<Self, SoundError> {
+        Ok(Self { path })
+    }
+
+    pub fn play(&self) -> Result<(), SoundError> {
+        // validate file again
+        validate_sound_file(&self.path)?;
+        // before playing the sound
+        let path = self.path.clone();
+
+        std::thread::spawn(move || -> Result<(), SoundError> {
+            // Important note: Never (ever) use a single `_` as a placeholder here. `_stream` or something is fine!
+            // The value will dropped and the sound will fail without any errors
+            // see https://github.com/RustAudio/rodio/issues/330
+            let (_stream, handle) =
+                OutputStream::try_default().map_err(|e| SoundError::OutputStream(e.to_string()))?;
+            let file = File::open(&path).map_err(|e| SoundError::File(e.to_string()))?;
+            let sink = Sink::try_new(&handle).map_err(|e| SoundError::Sink(e.to_string()))?;
+            let decoder = Decoder::new(BufReader::new(file))
+                .map_err(|e| SoundError::Decoder(e.to_string()))?;
+            sink.append(decoder);
+            sink.sleep_until_end();
+
+            Ok(())
+        });
+
+        Ok(())
+    }
+}
--- a/src/storage.rs
+++ b/src/storage.rs
@@ -1,5 +1,5 @@
 use crate::{
-    common::{AppTimeFormat, Content, Style},
+    common::{AppTimeFormat, Content, Style, Toggle},
    widgets::pomodoro::Mode as PomodoroMode,
 };
 use color_eyre::eyre::Result;
@@ -12,6 +12,8 @@ use std::time::Duration;
 pub struct AppStorage {
    pub content: Content,
    pub show_menu: bool,
+    pub notification: Toggle,
+    pub blink: Toggle,
    pub app_time_format: AppTimeFormat,
    pub style: Style,
    pub with_decis: bool,
@@ -38,6 +40,8 @@ impl Default for AppStorage {
        AppStorage {
            content: Content::default(),
            show_menu: true,
+            notification: Toggle::Off,
+            blink: Toggle::Off,
            app_time_format: AppTimeFormat::default(),
            style: Style::default(),
            with_decis: false,
--- a/src/terminal.rs
+++ b/src/terminal.rs
@@ -5,13 +5,14 @@ use crossterm::{
    cursor, execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen},
 };
-use ratatui::{backend::CrosstermBackend, Terminal as RatatuiTerminal};
+use ratatui::{Terminal as RatatuiTerminal, backend::CrosstermBackend};

 pub type Terminal = RatatuiTerminal<CrosstermBackend<io::Stdout>>;

 pub fn setup() -> Result<Terminal> {
    let mut stdout = std::io::stdout();
    crossterm::terminal::enable_raw_mode()?;
+    set_panic_hook();
    execute!(stdout, EnterAlternateScreen, cursor::Hide)?;
    let mut terminal = RatatuiTerminal::new(CrosstermBackend::new(stdout))?;
    terminal.clear()?;
@@ -24,3 +25,13 @@ pub fn teardown() -> Result<()> {
    crossterm::terminal::disable_raw_mode()?;
    Ok(())
 }
+
+// Panic hook
+// see https://ratatui.rs/tutorials/counter-app/error-handling/#setup-hooks
+fn set_panic_hook() {
+    let hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let _ = teardown(); // ignore any errors as we are already failing
+        hook(panic_info);
+    }));
+}
--- a/src/widgets/clock.rs
+++ b/src/widgets/clock.rs
@@ -10,11 +10,12 @@ use ratatui::{
 };

 use crate::{
-    common::Style,
+    common::{ClockTypeId, Style},
    duration::{DurationEx, MAX_DURATION, ONE_DECI_SECOND, ONE_HOUR, ONE_MINUTE, ONE_SECOND},
+    events::{AppEvent, AppEventTx},
    utils::center_horizontal,
    widgets::clock_elements::{
-        Colon, Digit, Dot, COLON_WIDTH, DIGIT_HEIGHT, DIGIT_SPACE_WIDTH, DIGIT_WIDTH, DOT_WIDTH,
+        COLON_WIDTH, Colon, DIGIT_HEIGHT, DIGIT_SPACE_WIDTH, DIGIT_WIDTH, DOT_WIDTH, Digit, Dot,
    },
 };

@@ -65,14 +66,24 @@ pub enum Format {
    HhMmSs,
 }

-#[derive(Debug, Clone)]
+const RANGE_OF_DONE_COUNT: u64 = 4;
+const MAX_DONE_COUNT: u64 = RANGE_OF_DONE_COUNT * 5;
+
 pub struct ClockState<T> {
+    type_id: ClockTypeId,
+    name: Option<String>,
    initial_value: DurationEx,
    current_value: DurationEx,
    tick_value: DurationEx,
    mode: Mode,
    format: Format,
    pub with_decis: bool,
+    app_tx: Option<AppEventTx>,
+    /// Tick counter starting whenever `Mode::DONE` has been reached.
+    /// Initial value is set in `done()`.
+    /// Updates happened in `update_done_count`
+    /// Default value: `None`
+    done_count: Option<u64>,
    phantom: PhantomData<T>,
 }

@@ -81,9 +92,23 @@ pub struct ClockStateArgs {
    pub current_value: Duration,
    pub tick_value: Duration,
    pub with_decis: bool,
+    pub app_tx: Option<AppEventTx>,
 }

 impl<T> ClockState<T> {
+    pub fn with_name(mut self, name: String) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn get_name(&self) -> String {
+        self.name.clone().unwrap_or_default()
+    }
+
+    pub fn get_type_id(&self) -> &ClockTypeId {
+        &self.type_id
+    }
+
    pub fn with_mode(mut self, mode: Mode) -> Self {
        self.mode = mode;
        self
@@ -310,6 +335,18 @@ impl<T> ClockState<T> {
        self.mode == Mode::Done
    }

+    fn done(&mut self) {
+        if !self.is_done() {
+            self.mode = Mode::Done;
+            let type_id = self.get_type_id().clone();
+            let name = self.get_name();
+            if let Some(tx) = &self.app_tx {
+                _ = tx.send(AppEvent::ClockDone(type_id, name));
+            };
+            self.done_count = Some(MAX_DONE_COUNT);
+        }
+    }
+
    fn update_format(&mut self) {
        self.format = self.get_format();
    }
@@ -329,6 +366,23 @@ impl<T> ClockState<T> {
            Format::S
        }
    }
+
+    /// Updates inner value of `done_count`.
+    /// It should be called whenever `TuiEvent::Tick` is handled.
+    /// At first glance it might happen in `Clock::tick`, but sometimes
+    /// `tick` won't be called again after `Mode::Done` event (e.g. in `widget::Countdown`).
+    /// That's why `update_done_count` is called from "outside".
+    pub fn update_done_count(&mut self) {
+        if let Some(count) = self.done_count {
+            if count > 0 {
+                let value = count - 1;
+                self.done_count = Some(value)
+            } else {
+                // None means we are done and no counting anymore.
+                self.done_count = None
+            }
+        }
+    }
 }

 #[derive(Debug, Clone)]
@@ -341,8 +395,11 @@ impl ClockState<Countdown> {
            current_value,
            tick_value,
            with_decis,
+            app_tx,
        } = args;
        let mut instance = Self {
+            type_id: ClockTypeId::Countdown,
+            name: None,
            initial_value: initial_value.into(),
            current_value: current_value.into(),
            tick_value: tick_value.into(),
@@ -355,6 +412,8 @@ impl ClockState<Countdown> {
            },
            format: Format::S,
            with_decis,
+            app_tx,
+            done_count: None,
            phantom: PhantomData,
        };
        // update format once
@@ -365,14 +424,14 @@ impl ClockState<Countdown> {
    pub fn tick(&mut self) {
        if self.mode == Mode::Tick {
            self.current_value = self.current_value.saturating_sub(self.tick_value);
-            self.set_done();
+            self.check_done();
            self.update_format();
        }
    }

-    fn set_done(&mut self) {
+    fn check_done(&mut self) {
        if self.current_value.eq(&Duration::ZERO.into()) {
-            self.mode = Mode::Done;
+            self.done();
        }
    }

@@ -409,8 +468,11 @@ impl ClockState<Timer> {
            current_value,
            tick_value,
            with_decis,
+            app_tx,
        } = args;
        let mut instance = Self {
+            type_id: ClockTypeId::Timer,
+            name: None,
            initial_value: initial_value.into(),
            current_value: current_value.into(),
            tick_value: tick_value.into(),
@@ -422,8 +484,10 @@ impl ClockState<Timer> {
                Mode::Pause
            },
            format: Format::S,
-            phantom: PhantomData,
            with_decis,
+            app_tx,
+            done_count: None,
+            phantom: PhantomData,
        };
        // update format once
        instance.update_format();
@@ -433,14 +497,14 @@ impl ClockState<Timer> {
    pub fn tick(&mut self) {
        if self.mode == Mode::Tick {
            self.current_value = self.current_value.saturating_add(self.tick_value);
-            self.set_done();
+            self.check_done();
            self.update_format();
        }
    }

-    fn set_done(&mut self) {
+    fn check_done(&mut self) {
        if self.current_value.ge(&MAX_DURATION.into()) {
-            self.mode = Mode::Done;
+            self.done();
        }
    }

@@ -466,6 +530,7 @@ where
    T: std::fmt::Debug,
 {
    style: Style,
+    blink: bool,
    phantom: PhantomData<T>,
 }

@@ -473,9 +538,10 @@ impl<T> ClockWidget<T>
 where
    T: std::fmt::Debug,
 {
-    pub fn new(style: Style) -> Self {
+    pub fn new(style: Style, blink: bool) -> Self {
        Self {
            style,
+            blink,
            phantom: PhantomData,
        }
    }
@@ -568,6 +634,17 @@ where
    pub fn get_height(&self) -> u16 {
        DIGIT_HEIGHT
    }
+
+    /// Checks whether to blink the clock while rendering.
+    /// Its logic is based on a given `count` value.
+    fn should_blink(&self, count_value: &Option<u64>) -> bool {
+        // Example:
+        // if `RANGE_OF_DONE_COUNT` is 4
+        // then for ranges `0..4`, `8..12` etc. it will return `true`
+        count_value
+            .map(|b| (b % (RANGE_OF_DONE_COUNT * 2)) < RANGE_OF_DONE_COUNT)
+            .unwrap_or(false)
+    }
 }

 impl<T> StatefulWidget for ClockWidget<T>
@@ -579,7 +656,13 @@ where
    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        let with_decis = state.with_decis;
        let format = state.format;
-        let symbol = self.style.get_digit_symbol();
+        // to simulate a blink effect, just use an "empty" symbol (string)
+        // to "empty" all digits and to have an "empty" render area
+        let symbol = if self.blink && self.should_blink(&state.done_count) {
+            " "
+        } else {
+            self.style.get_digit_symbol()
+        };
        let widths = self.get_horizontal_lengths(&format, with_decis);
        let area = center_horizontal(
            area,
--- a/src/widgets/clock_test.rs
+++ b/src/widgets/clock_test.rs
@@ -1,34 +1,33 @@
 use crate::{
+    common::ClockTypeId,
    duration::{ONE_DECI_SECOND, ONE_HOUR, ONE_MINUTE, ONE_SECOND},
    widgets::clock::*,
 };
 use std::time::Duration;

-#[test]
-fn test_toggle_edit() {
-    let mut c = ClockState::<Timer>::new(ClockStateArgs {
+fn default_args() -> ClockStateArgs {
+    ClockStateArgs {
        initial_value: ONE_HOUR,
        current_value: ONE_HOUR,
        tick_value: ONE_DECI_SECOND,
-        with_decis: true,
-    });
-    // off by default
-    assert!(!c.is_edit_mode());
-    // toggle on
-    c.toggle_edit();
-    assert!(c.is_edit_mode());
-    // toggle off
-    c.toggle_edit();
-    assert!(!c.is_edit_mode());
+        with_decis: false,
+        app_tx: None,
+    }
+}
+
+#[test]
+fn test_type_id() {
+    let c = ClockState::<Timer>::new(default_args());
+    assert!(matches!(c.get_type_id(), ClockTypeId::Timer));
+    let c = ClockState::<Countdown>::new(default_args());
+    assert!(matches!(c.get_type_id(), ClockTypeId::Countdown));
 }

 #[test]
 fn test_default_edit_mode_hhmmss() {
    let mut c = ClockState::<Timer>::new(ClockStateArgs {
-        initial_value: ONE_HOUR,
-        current_value: ONE_HOUR,
-        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        ..default_args()
    });

    // toggle on
@@ -43,6 +42,7 @@ fn test_default_edit_mode_mmss() {
        current_value: ONE_MINUTE,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });
    // toggle on
    c.toggle_edit();
@@ -56,6 +56,7 @@ fn test_default_edit_mode_ss() {
        current_value: ONE_SECOND,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });
    // toggle on
    c.toggle_edit();
@@ -69,6 +70,7 @@ fn test_edit_next_hhmmssd() {
        current_value: ONE_HOUR,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -90,6 +92,7 @@ fn test_edit_next_hhmmss() {
        current_value: ONE_HOUR,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -109,6 +112,7 @@ fn test_edit_next_mmssd() {
        current_value: ONE_MINUTE,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -128,6 +132,7 @@ fn test_edit_next_mmss() {
        current_value: ONE_MINUTE,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -145,6 +150,7 @@ fn test_edit_next_ssd() {
        current_value: ONE_SECOND * 3,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -160,6 +166,7 @@ fn test_edit_next_ss() {
        current_value: ONE_SECOND * 3,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -176,6 +183,7 @@ fn test_edit_prev_hhmmssd() {
        current_value: ONE_HOUR,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -196,6 +204,7 @@ fn test_edit_prev_hhmmss() {
        current_value: ONE_HOUR,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -214,6 +223,7 @@ fn test_edit_prev_mmssd() {
        current_value: ONE_MINUTE,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -234,6 +244,7 @@ fn test_edit_prev_mmss() {
        current_value: ONE_MINUTE,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -252,6 +263,7 @@ fn test_edit_prev_ssd() {
        current_value: ONE_SECOND,
        tick_value: ONE_DECI_SECOND,
        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -270,6 +282,7 @@ fn test_edit_prev_ss() {
        current_value: ONE_SECOND,
        tick_value: ONE_DECI_SECOND,
        with_decis: false,
+        app_tx: None,
    });

    // toggle on
@@ -285,7 +298,8 @@ fn test_edit_up_ss() {
        initial_value: Duration::ZERO,
        current_value: Duration::ZERO,
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -301,7 +315,8 @@ fn test_edit_up_mmss() {
        initial_value: Duration::ZERO,
        current_value: Duration::from_secs(60),
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -320,7 +335,8 @@ fn test_edit_up_hhmmss() {
        initial_value: Duration::ZERO,
        current_value: Duration::from_secs(3600),
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -341,7 +357,8 @@ fn test_edit_down_ss() {
        initial_value: Duration::ZERO,
        current_value: ONE_SECOND,
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -361,7 +378,8 @@ fn test_edit_down_mmss() {
        initial_value: Duration::ZERO,
        current_value: Duration::from_secs(120),
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
@@ -383,7 +401,8 @@ fn test_edit_down_hhmmss() {
        initial_value: Duration::ZERO,
        current_value: Duration::from_secs(3600),
        tick_value: ONE_DECI_SECOND,
-        with_decis: false,
+        with_decis: true,
+        app_tx: None,
    });

    // toggle on
--- a/src/widgets/countdown.rs
+++ b/src/widgets/countdown.rs
@@ -2,11 +2,11 @@ use crate::{
    common::{AppTime, Style},
    constants::TICK_VALUE_MS,
    duration::{DurationEx, MAX_DURATION},
-    events::{Event, EventHandler},
+    events::{AppEventTx, TuiEvent, TuiEventHandler},
    utils::center,
    widgets::{
        clock::{self, ClockState, ClockStateArgs, ClockWidget, Mode as ClockMode},
-        edit_time::EditTimeState,
+        edit_time::{EditTimeState, EditTimeStateArgs, EditTimeWidget},
    },
 };
 use crossterm::event::KeyModifiers;
@@ -17,15 +17,20 @@ use ratatui::{
    text::Line,
    widgets::{StatefulWidget, Widget},
 };
-
 use std::ops::Sub;
 use std::{cmp::max, time::Duration};
 use time::OffsetDateTime;

-use super::edit_time::{EditTimeStateArgs, EditTimeWidget};
+pub struct CountdownStateArgs {
+    pub initial_value: Duration,
+    pub current_value: Duration,
+    pub elapsed_value: Duration,
+    pub app_time: AppTime,
+    pub with_decis: bool,
+    pub app_tx: AppEventTx,
+}

 /// State for Countdown Widget
-#[derive(Debug, Clone)]
 pub struct CountdownState {
    /// clock to count down
    clock: ClockState<clock::Countdown>,
@@ -37,19 +42,32 @@ pub struct CountdownState {
 }

 impl CountdownState {
-    pub fn new(
-        clock: ClockState<clock::Countdown>,
-        elapsed_value: Duration,
-        app_time: AppTime,
-    ) -> Self {
+    pub fn new(args: CountdownStateArgs) -> Self {
+        let CountdownStateArgs {
+            initial_value,
+            current_value,
+            elapsed_value,
+            with_decis,
+            app_time,
+            app_tx,
+        } = args;
+
        Self {
-            clock,
+            clock: ClockState::<clock::Countdown>::new(ClockStateArgs {
+                initial_value,
+                current_value,
+                tick_value: Duration::from_millis(TICK_VALUE_MS),
+                with_decis,
+                app_tx: Some(app_tx.clone()),
+            }),
            elapsed_clock: ClockState::<clock::Timer>::new(ClockStateArgs {
                initial_value: Duration::ZERO,
                current_value: elapsed_value,
                tick_value: Duration::from_millis(TICK_VALUE_MS),
                with_decis: false,
+                app_tx: None,
            })
+            .with_name("MET".to_owned())
            // A previous `elapsed_value > 0` means the `Clock` was running before,
            // but not in `Initial` state anymore. Updating `Mode` here
            // is needed to handle `Event::Tick` in `EventHandler::update` properly
@@ -124,15 +142,14 @@ impl CountdownState {
    }
 }

-impl EventHandler for CountdownState {
-    fn update(&mut self, event: Event) -> Option<Event> {
-        let is_edit_clock = self.clock.is_edit_mode();
-        let is_edit_time = self.edit_time.is_some();
+impl TuiEventHandler for CountdownState {
+    fn update(&mut self, event: TuiEvent) -> Option<TuiEvent> {
        match event {
-            Event::Tick => {
+            TuiEvent::Tick => {
                if !self.clock.is_done() {
                    self.clock.tick();
                } else {
+                    self.clock.update_done_count();
                    self.elapsed_clock.tick();
                    if self.elapsed_clock.is_initial() {
                        self.elapsed_clock.run();
@@ -145,7 +162,7 @@ impl EventHandler for CountdownState {
                    edit_time.set_max_time(max_time);
                }
            }
-            Event::Key(key) => match key.code {
+            TuiEvent::Key(key) => match key.code {
                KeyCode::Char('r') => {
                    // reset both clocks to use intial values
                    self.clock.reset();
@@ -172,11 +189,9 @@ impl EventHandler for CountdownState {
                }
                // STRG + e => toggle edit time
                KeyCode::Char('e') if key.modifiers.contains(KeyModifiers::CONTROL) => {
-                    // stop editing clock
-                    if self.clock.is_edit_mode() {
-                        // toggle edit mode
-                        self.clock.toggle_edit();
-                    }
+                    // reset both clocks
+                    self.clock.reset();
+                    self.elapsed_clock.reset();

                    if let Some(edit_time) = &mut self.edit_time.clone() {
                        self.edit_time_done(edit_time)
@@ -188,18 +203,8 @@ impl EventHandler for CountdownState {
                            max: self.max_time_to_edit(),
                        }));
                    }
-
-                    // stop `clock`
-                    if self.clock.is_running() {
-                        self.clock.toggle_pause();
                }
-
-                    // stop `elapsed_clock`
-                    if self.elapsed_clock.is_running() {
-                        self.elapsed_clock.toggle_pause();
-                    }
-                }
-                // STRG + e => toggle edit clock
+                // e => toggle edit clock
                KeyCode::Char('e') => {
                    // toggle edit mode
                    self.clock.toggle_edit();
@@ -208,47 +213,38 @@ impl EventHandler for CountdownState {
                    if self.elapsed_clock.is_running() {
                        self.elapsed_clock.toggle_pause();
                    }
-
-                    // finish `edit_time` and continue for using `clock`
-                    if let Some(edit_time) = &mut self.edit_time.clone() {
-                        self.edit_time_done(edit_time);
                }
-                }
-                KeyCode::Left if is_edit_clock => {
+                KeyCode::Left if self.is_clock_edit_mode() => {
                    self.clock.edit_next();
                }
-                KeyCode::Left if is_edit_time => {
-                    // safe unwrap because of previous check in `is_edit_time`
+                KeyCode::Left if self.is_time_edit_mode() => {
+                    // safe unwrap because of previous check in `is_time_edit_mode`
                    self.edit_time.as_mut().unwrap().next();
                }
-                KeyCode::Right if is_edit_clock => {
+                KeyCode::Right if self.is_clock_edit_mode() => {
                    self.clock.edit_prev();
                }
-                KeyCode::Right if is_edit_time => {
-                    // safe unwrap because of previous check in `is_edit_time`
+                KeyCode::Right if self.is_time_edit_mode() => {
+                    // safe unwrap because of previous check in `is_time_edit_mode`
                    self.edit_time.as_mut().unwrap().prev();
                }
-                KeyCode::Up if is_edit_clock => {
+                KeyCode::Up if self.is_clock_edit_mode() => {
                    self.clock.edit_up();
                    // whenever `clock`'s value is changed, reset `elapsed_clock`
                    self.elapsed_clock.reset();
                }
-                KeyCode::Up if is_edit_time => {
-                    // safe unwrap because of previous check in `is_edit_time`
+                KeyCode::Up if self.is_time_edit_mode() => {
+                    // safe unwrap because of previous check in `is_time_edit_mode`
                    self.edit_time.as_mut().unwrap().up();
-                    // whenever `clock`'s value is changed, reset `elapsed_clock`
-                    self.elapsed_clock.reset();
                }
-                KeyCode::Down if is_edit_clock => {
+                KeyCode::Down if self.is_clock_edit_mode() => {
                    self.clock.edit_down();
                    // whenever clock value is changed, reset timer
                    self.elapsed_clock.reset();
                }
-                KeyCode::Down if is_edit_time => {
-                    // safe unwrap because of previous check in `is_edit_time`
+                KeyCode::Down if self.is_time_edit_mode() => {
+                    // safe unwrap because of previous check in `is_time_edit_mode`
                    self.edit_time.as_mut().unwrap().down();
-                    // whenever clock value is changed, reset timer
-                    self.elapsed_clock.reset();
                }
                _ => return Some(event),
            },
@@ -260,6 +256,7 @@ impl EventHandler for CountdownState {

 pub struct Countdown {
    pub style: Style,
+    pub blink: bool,
 }

 fn human_days_diff(a: &OffsetDateTime, b: &OffsetDateTime) -> String {
@@ -319,7 +316,7 @@ impl StatefulWidget for Countdown {
                }
                .to_uppercase(),
            );
-            let widget = ClockWidget::new(self.style);
+            let widget = ClockWidget::new(self.style, self.blink);
            let area = center(
                area,
                Constraint::Length(max(
--- a/src/widgets/edit_time.rs
+++ b/src/widgets/edit_time.rs
@@ -9,7 +9,7 @@ use ratatui::{

 use crate::{
    common::Style,
-    widgets::clock_elements::{Colon, Digit, COLON_WIDTH, DIGIT_SPACE_WIDTH, DIGIT_WIDTH},
+    widgets::clock_elements::{COLON_WIDTH, Colon, DIGIT_SPACE_WIDTH, DIGIT_WIDTH, Digit},
 };

 use super::clock_elements::DIGIT_HEIGHT;
--- a/src/widgets/footer.rs
+++ b/src/widgets/footer.rs
@@ -155,7 +155,7 @@ impl StatefulWidget for Footer {
                                    if self.selected_content == Content::Countdown {
                                        spans.extend_from_slice(&[
                                            Span::from(SPACE),
-                                            Span::from("[ctrl+e]dit by local time"),
+                                            Span::from("[^e]dit by local time"),
                                        ]);
                                    }
                                    if self.selected_content == Content::Pomodoro {
@@ -169,7 +169,7 @@ impl StatefulWidget for Footer {
                                others => vec![
                                    Span::from(match others {
                                        AppEditMode::Clock => "[e]dit done",
-                                        AppEditMode::Time => "[ctrl+e]dit done",
+                                        AppEditMode::Time => "[^e]dit done",
                                        _ => "",
                                    }),
                                    Span::from(SPACE),
--- a/src/widgets/pomodoro.rs
+++ b/src/widgets/pomodoro.rs
@@ -1,9 +1,9 @@
 use crate::{
    common::Style,
    constants::TICK_VALUE_MS,
-    events::{Event, EventHandler},
+    events::{AppEventTx, TuiEvent, TuiEventHandler},
    utils::center,
-    widgets::clock::{ClockState, ClockWidget, Countdown},
+    widgets::clock::{ClockState, ClockStateArgs, ClockWidget, Countdown},
 };
 use ratatui::{
    buffer::Buffer,
@@ -12,13 +12,9 @@ use ratatui::{
    text::Line,
    widgets::{StatefulWidget, Widget},
 };
-use std::{cmp::max, time::Duration};
-
-use strum::Display;
-
 use serde::{Deserialize, Serialize};
-
-use super::clock::ClockStateArgs;
+use std::{cmp::max, time::Duration};
+use strum::Display;

 #[derive(Debug, Clone, Display, Hash, Eq, PartialEq, Deserialize, Serialize)]
 pub enum Mode {
@@ -26,7 +22,6 @@ pub enum Mode {
    Pause,
 }

-#[derive(Debug, Clone)]
 pub struct ClockMap {
    work: ClockState<Countdown>,
    pause: ClockState<Countdown>,
@@ -47,7 +42,6 @@ impl ClockMap {
    }
 }

-#[derive(Debug, Clone)]
 pub struct PomodoroState {
    mode: Mode,
    clock_map: ClockMap,
@@ -60,6 +54,7 @@ pub struct PomodoroStateArgs {
    pub initial_value_pause: Duration,
    pub current_value_pause: Duration,
    pub with_decis: bool,
+    pub app_tx: AppEventTx,
 }

 impl PomodoroState {
@@ -71,6 +66,7 @@ impl PomodoroState {
            initial_value_pause,
            current_value_pause,
            with_decis,
+            app_tx,
        } = args;
        Self {
            mode,
@@ -80,13 +76,17 @@ impl PomodoroState {
                    current_value: current_value_work,
                    tick_value: Duration::from_millis(TICK_VALUE_MS),
                    with_decis,
-                }),
+                    app_tx: Some(app_tx.clone()),
+                })
+                .with_name("Work".to_owned()),
                pause: ClockState::<Countdown>::new(ClockStateArgs {
                    initial_value: initial_value_pause,
                    current_value: current_value_pause,
                    tick_value: Duration::from_millis(TICK_VALUE_MS),
                    with_decis,
-                }),
+                    app_tx: Some(app_tx),
+                })
+                .with_name("Pause".to_owned()),
            },
        }
    }
@@ -124,14 +124,15 @@ impl PomodoroState {
    }
 }

-impl EventHandler for PomodoroState {
-    fn update(&mut self, event: Event) -> Option<Event> {
+impl TuiEventHandler for PomodoroState {
+    fn update(&mut self, event: TuiEvent) -> Option<TuiEvent> {
        let edit_mode = self.get_clock().is_edit_mode();
        match event {
-            Event::Tick => {
+            TuiEvent::Tick => {
                self.get_clock_mut().tick();
+                self.get_clock_mut().update_done_count();
            }
-            Event::Key(key) => match key.code {
+            TuiEvent::Key(key) => match key.code {
                KeyCode::Char('s') => {
                    self.get_clock_mut().toggle_pause();
                }
@@ -170,12 +171,13 @@ impl EventHandler for PomodoroState {

 pub struct PomodoroWidget {
    pub style: Style,
+    pub blink: bool,
 }

 impl StatefulWidget for PomodoroWidget {
    type State = PomodoroState;
    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-        let clock_widget = ClockWidget::new(self.style);
+        let clock_widget = ClockWidget::new(self.style, self.blink);
        let label = Line::raw(
            (format!(
                "Pomodoro {} {}",
--- a/src/widgets/timer.rs
+++ b/src/widgets/timer.rs
@@ -1,6 +1,6 @@
 use crate::{
    common::Style,
-    events::{Event, EventHandler},
+    events::{TuiEvent, TuiEventHandler},
    utils::center,
    widgets::clock::{self, ClockState, ClockWidget},
 };
@@ -13,7 +13,6 @@ use ratatui::{
 };
 use std::cmp::max;

-#[derive(Debug, Clone)]
 pub struct TimerState {
    clock: ClockState<clock::Timer>,
 }
@@ -32,14 +31,15 @@ impl TimerState {
    }
 }

-impl EventHandler for TimerState {
-    fn update(&mut self, event: Event) -> Option<Event> {
+impl TuiEventHandler for TimerState {
+    fn update(&mut self, event: TuiEvent) -> Option<TuiEvent> {
        let edit_mode = self.clock.is_edit_mode();
        match event {
-            Event::Tick => {
+            TuiEvent::Tick => {
                self.clock.tick();
+                self.clock.update_done_count();
            }
-            Event::Key(key) => match key.code {
+            TuiEvent::Key(key) => match key.code {
                KeyCode::Char('s') => {
                    self.clock.toggle_pause();
                }
@@ -71,13 +71,14 @@ impl EventHandler for TimerState {

 pub struct Timer {
    pub style: Style,
+    pub blink: bool,
 }

 impl StatefulWidget for Timer {
    type State = TimerState;
    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        let clock = &mut state.clock;
-        let clock_widget = ClockWidget::new(self.style);
+        let clock_widget = ClockWidget::new(self.style, self.blink);
        let label = Line::raw((format!("Timer {}", clock.get_mode())).to_uppercase());

        let area = center(
Author	SHA1	Message	Date
jk	675428cfb0	Update README	2025-04-17 08:31:40 +02:00
Jens Krause	28c5d7194c	Rust 1.86.0 (#73 )	2025-04-13 21:37:47 +02:00
Jens Krause	5b445afe25	fix(countdown): reset `MET` while editing by local time (#72 )	2025-04-13 21:17:56 +02:00
jk	beb12d5ec2	just: run with args	2025-04-13 19:19:46 +02:00
Jens Krause	d9399eafc9	fix(countdown): Reset `MET` if `countdown` is set by cli arguments (#71 ) * fix: Reset MET if countdown is set by args * update CHANGELOG	2025-03-03 12:21:17 +01:00
Jens Krause	ffad78e093	fix(just): `group` commands (#70 )	2025-02-26 14:58:54 +01:00
jk	e7a5a1b2da	exclude files for packaging	2025-02-26 12:31:18 +01:00
Jens Krause	6f0df4d488	Prepare v1.2.0 (#69 ) * prepare v1.2.0 * update README * update justfile	2025-02-26 12:11:54 +01:00
Jens Krause	3d9b235f12	`Rust 1.85.0` + `Rust 2024 Edition` (#68 ) - Add `rust-toolchain.toml` - Refactor `flake` to consider `rust-toolchain.toml`, especially Rust version - `just`: Add run-sound command - Ignore sound files - Format	2025-02-25 20:30:20 +01:00
jk	e094d7d81b	feat(logging): add `--log` arg to enable logs and/or to pass a custom log directory.	2025-02-06 20:33:52 +01:00
Jens Krause	843c4d019d	`set_panic_hook` (#67 )	2025-02-06 11:16:04 +01:00
Jens Krause	e95ecb9e9c	feat(notification): Animate (blink) clock entering `done` mode (#65 ) Optional.	2025-02-05 19:29:56 +01:00
Jens Krause	886deb3311	fix(notification): remove `callbacks` in favour of `mpsc` messaging (#64 )	2025-02-05 13:35:24 +01:00
Jens Krause	7ff167368d	`--features sound` (#63 ) to enable `sound` notification for local builds only. Needed to avoid endless issues by building the app for different platforms. Sound support can be hard.	2025-02-04 17:39:50 +01:00
Jens Krause	a54b1b409a	feat(clock): `sound` notification (experimental) (#62 )	2025-02-04 17:28:41 +01:00
Jens Krause	8f50bc5fc6	`AppEvent` (#61 ) Extend `events` to provide a `mpsc` channel to send `AppEvent`'s from anywhere in the app straight to the `App`.	2025-02-04 15:05:02 +01:00
Jens Krause	d3c436da0b	feat: native desktop notifications (experimental) (#59 ) * desktop notification by entering `Mode::DONE` for `countdown` and `pomodoro` * remove redundant `on_done_called` check * remove build warning (release only) * log notification errors * cli arg to enable desktop notifications * persistant notification settings * ctrl shortcut * update changelog * max timer notification	2025-01-28 19:28:34 +01:00
jk	97787f718d	remove editor settings (zed)	2025-01-26 18:49:14 +01:00
Jens Krause	557fcf95f0	Prepare v1.1.0 (#58 )	2025-01-22 10:55:20 +01:00