Feature request: Change notification opacity on hover

[markg85]

Hi,

I think in Gnome and/or Ubuntu when a notification pops up and when you hover it with your mouse, it fades out to say 10% or so.
Can we get that in dunst too?

I don't know if that is still a thing. It's been quite some time since i last used either of those. Things might have changes (in the last 10 years or so).

Edit..
A slightly related request. While you haver a notification, don't close it! Technically this is probably in the same code path. Especially to make both features possible.

Edit 2..
In fact, it might make more sense to allow user scripts to run on mouse enter/leave. The user script could then instruct the window manager to change the opacity. The timeout pause probably does need to be handled inside dunst.

[bynect]

This is an interesting idea 👍
I also had thought about adding some hook on hover.

[markg85]

I partly implemented this.

Disclaimer: Not final code, not proper in your style, not done at all!

With that out of the way, here's what i did and why.

1. I added two new properties to the notification struct:
   1.1. timeout_remainder which stores for how long the notification is still visible.
   1.2. paused which tells if the notification is paused (mouse hovers over it) or not. I did not want to fiddle with timeout though that could've worked too. When the notification is paused the timeout_remainder stays as is and the start property gets reset on every queues_notification_is_finished. Once paused becomes false again it essentially starts a timer from the then current time till whatever is left in timeout_remainder. This seemed clean to me.
2. Added input_handle_enter which now stores a global notification object in hovered_notification and sets the timer to false when this function is hit.
3. Added input_handle_leave which resumes (paused back to false) and cleans up hovered_notification.

I still have to add the script invocation for an enter event but i leave that for a later time. I'd like to know if my changes in their rough shape are leaning towards acceptable or if i need to take a completely different approach? I'm talking about the code itself, it obviously has to go though a PR to make all out lives easier but i just like to get a little early on feedback to keep me on the right technical track.

I'm aware that there's something not entirely correct in the remainder and how it restarts. It works, but sometime acts a little wonky. I coded this essentially blindly (no IDE, just plain nano). I'm already happy that it works as well as it does 🙂

Here's the diff:

diff --git a/src/input.c b/src/input.c
index 979778f..8d31ec7 100644
--- a/src/input.c
+++ b/src/input.c
@@ -13,6 +13,9 @@
 #define BTN_TOUCH	(0x14a)
 #endif
 
+// Static variable to track the currently hovered notification
+static struct notification *hovered_notification = NULL;
+
 int get_notification_clickable_height(struct notification *n, bool first, bool last)
 {
         int notification_size = n->displayed_height;
@@ -116,4 +119,27 @@ void input_handle_click(unsigned int button, bool button_down, int mouse_x, int
 
         wake_up();
 }
+
+void input_handle_enter(int mouse_x, int mouse_y){
+    // Find the notification under the cursor
+    struct notification *n = get_notification_at(mouse_y);
+
+    if (n != hovered_notification) {
+        // Handle previous hovered notification if needed
+        if (hovered_notification) {
+            input_handle_leave();
+        }
+
+        hovered_notification = n;
+        hovered_notification->paused = true;
+    }
+}
+
+void input_handle_leave(){
+    if (hovered_notification) {
+        hovered_notification->paused = false;
+        hovered_notification = NULL;
+    }
+}
+
 /* vim: set ft=c tabstop=8 shiftwidth=8 expandtab textwidth=0: */
diff --git a/src/input.h b/src/input.h
index 343f46d..c475fbc 100644
--- a/src/input.h
+++ b/src/input.h
@@ -14,5 +14,8 @@
  */
 void input_handle_click(unsigned int button, bool button_down, int mouse_x, int mouse_y);
 
+void input_handle_enter(int mouse_x, int mouse_y);
+void input_handle_leave();
+
 #endif
 /* vim: set ft=c tabstop=8 shiftwidth=8 expandtab textwidth=0: */
diff --git a/src/notification.c b/src/notification.c
index 6a0d4fe..fa8e06a 100644
--- a/src/notification.c
+++ b/src/notification.c
@@ -450,9 +450,11 @@ struct notification *notification_create(void)
 
         n->urgency = URG_NORM;
         n->timeout = -1;
+        n->timeout_remainder = -1;
         n->dbus_timeout = -1;
 
         n->transient = false;
+        n->paused = false;
         n->progress = -1;
         n->word_wrap = true;
         n->ellipsize = PANGO_ELLIPSIZE_MIDDLE;
@@ -500,8 +502,10 @@ void notification_init(struct notification *n)
                 n->urgency = URG_CRIT;
 
         /* Timeout processing */
-        if (n->timeout < 0)
+        if (n->timeout < 0) {
                 n->timeout = settings.timeouts[n->urgency];
+                n->timeout_remainder = n->timeout;
+        }
 
         /* Color hints */
         struct notification_colors defcolors;
@@ -556,8 +560,10 @@ void notification_init(struct notification *n)
         notification_format_message(n);
 
         /* Update timeout: dbus_timeout has priority over timeout */
-        if (n->dbus_timeout >= 0)
+        if (n->dbus_timeout >= 0) {
                 n->timeout = n->dbus_timeout;
+                n->timeout_remainder = n->timeout;
+        }
 
 }
 
diff --git a/src/notification.h b/src/notification.h
index 7d2f0d6..13d6d64 100644
--- a/src/notification.h
+++ b/src/notification.h
@@ -77,6 +77,7 @@ struct notification {
         gint64 start;      /**< begin of current display (in milliseconds) */
         gint64 timestamp;  /**< arrival time (in milliseconds) */
         gint64 timeout;    /**< time to display (in milliseconds) */
+        gint64 timeout_remainder;    /**< remaining time to display (in milliseconds) */
         gint64 dbus_timeout; /**< time to display (in milliseconds) (set by dbus) */
         int locked;     /**< If non-zero the notification is locked **/
         PangoAlignment progress_bar_alignment; /**< Horizontal alignment of the progress bar **/
@@ -94,6 +95,7 @@ struct notification {
 
         /* Hints */
         bool transient;     /**< timeout albeit user is idle */
+        bool paused;     /**< pause the timeout countdown */
         int progress;       /**< percentage (-1: undefined) */
         int history_ignore; /**< push to history or free directly */
         int skip_display;   /**< insert notification into history, skipping initial waiting and display */
diff --git a/src/queues.c b/src/queues.c
index d578b47..82ecb74 100644
--- a/src/queues.c
+++ b/src/queues.c
@@ -159,8 +159,16 @@ static bool queues_notification_is_finished(struct notification *n, struct dunst
                 return false;
         }
 
+        /* decrease timer if we're not paused (happens with the mouse over the notification) */
+        if (!n->paused) {
+                n->timeout_remainder = n->timeout - (time - n->start);
+        } else {
+                /* reset the start time when paused. Once we resume it counts as a new start for the remainder */
+                n->start = time_monotonic_now();
+        }
+
         /* remove old message */
-        if (time - n->start > n->timeout) {
+        if (n->timeout_remainder <= 0) {
                 return true;
         }
 
diff --git a/src/wayland/wl_seat.c b/src/wayland/wl_seat.c
index ffc1e48..fd38e43 100644
--- a/src/wayland/wl_seat.c
+++ b/src/wayland/wl_seat.c
@@ -79,12 +79,15 @@ static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer,
                 wp_cursor_shape_device_v1_set_shape(device, serial,
                                 WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT);
                 wp_cursor_shape_device_v1_destroy(device);
+                input_handle_enter(wl_fixed_to_int(x), wl_fixed_to_int(y));
                 return;
         }
 #endif
         if (ctx.cursor_theme != NULL) {
                 wl_pointer_set_cursor(wl_pointer, serial, ctx.cursor_surface, ctx.cursor_image->hotspot_x, ctx.cursor_image->hotspot_y);
         }
+
+        input_handle_enter(wl_fixed_to_int(x), wl_fixed_to_int(y));
 }
 
 static void pointer_handle_motion(void *data, struct wl_pointer *wl_pointer,
@@ -105,6 +108,7 @@ static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
 
 static void pointer_handle_leave(void *data, struct wl_pointer *wl_pointer,
                 uint32_t serial, struct wl_surface *surface) {
+        input_handle_leave();
 }
 
 static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,

[bynect]

Thanks. When I have the time I will integrate this in dunst 👍

[markg85]

I take it that you have no objections to the approach i took then ;)
Do you want me to finish the implementation (adding a script hook for both entered and leave) and make a PR out of it?

[bynect]

I have two main concern.

First: what if the notification is closed by dunstctl close while hovering? It seems the notification is kept in the global variable

Second: maybe we can adjust differently the way the timout is handled. But I have to think about that a little more

[markg85]

Thank you so much for that little bit of insight into the code! I had not even considered that at all (i didn't even know the feature existed). I'll fix that. I'll go the PR route for further feedback. Expect that one to hit your email in a few days or so.

Regarding the timeout. Initially i wanted to just set it at 0 when hovering, but then you don't know if that 0 came from hovering or if it always was 0.. So i needed something to maintain state which i introduced with the "paused" property (code only, intentionally not user configurable). I'm not too happy about reusing start so i might add another time property called "resume_time" which would be 0 by default. If it's 0, for any calculation start will be used. If it's non-zero then resume_time is used. This does give a little bit more complexity which i'm not too happy about either but it might be cleaner in terms of not reusing/abusing existing properties for a new feature.