Temporalily fix hidden block event

5 files changed, 90 insertions, 50 deletions

diff --git a/src/blocks/slider.c b/src/blocks/slider.c
index 5ed69de..228dec2 100644
--- a/src/blocks/slider.c
+++ b/src/blocks/slider.c
@@ -171,21 +171,9 @@ static void block_slider_event(layout_t *layout, event_t event)
     block_slider_t *slider = (block_slider_t *)layout->block;
     int value = slider->value;
 
-    if (!slider->seekable) return;
-
-    if (event.type == EVENT_HOVER_START) {
-        log_warn("STARTED HOVER");
+    if (layout->block->hidden) return;
 
-        gradient_t tmp = slider->bar_color;
-        slider->bar_color = slider->block.block.bg_color;
-        slider->block.block.bg_color= tmp;
-    }
-    if (event.type == EVENT_HOVER_STOP) {
-        log_warn("STOP HOVER");
-        gradient_t tmp = slider->bar_color;
-        slider->bar_color = slider->block.block.bg_color;
-        slider->block.block.bg_color= tmp;
-    }
+    if (!slider->seekable) return;
 
     if (event_is_click(event)) {
         int bar_x = layout->x + (layout->width - slider->width) / 2;
@@ -201,7 +189,7 @@ static void block_slider_event(layout_t *layout, event_t event)
 
         if (slider->value > 100) slider->value = 100;
         if (slider->value < 0)   slider->value = 0;
-    }
+    } else return;
 
     log_value_debug("Updated slider value",
                     "s:label", layout->block->label,
diff --git a/src/config.c b/src/config.c
index fc1acf8..a85fee7 100644
--- a/src/config.c
+++ b/src/config.c
@@ -675,6 +675,8 @@ void config_free(config_t *config)
     for (int i = 0; i < config->n_blocks; i++)
         block_free(config->blocks[i]);
 
+    gradient_free(&config->background);
+
     free(config->blocks);
     free(config->font);
     free(config->monitor);
diff --git a/src/event.c b/src/event.c
index 3c1ae81..c2c98ab 100644
--- a/src/event.c
+++ b/src/event.c
@@ -24,11 +24,9 @@ const char *event_type_to_string(event_type_t type)
     return types[type];
 }
 
-bool event_is_hover(event_t event)
+bool event_is_trigger(event_t event)
 {
-    return event.type == EVENT_HOVER_START
-        || event.type == EVENT_HOVER_MOVE
-        || event.type == EVENT_HOVER_STOP;
+    return event.type == EVENT_TRIGGER;
 }
 
 bool event_is_click(event_t event)
@@ -44,13 +42,33 @@ bool event_is_scroll(event_t event)
         || event.type == EVENT_SCROLL_DOWN;
 }
 
+bool event_is_hover(event_t event)
+{
+    return event.type == EVENT_HOVER_START
+        || event.type == EVENT_HOVER_MOVE
+        || event.type == EVENT_HOVER_STOP;
+}
+
+static layout_t *event_dispatch_find(block_t *block, layout_t *layout)
+{
+    if (layout->block == block)
+        return layout;
+
+    for (size_t i = 0; i < layout->n_children; i++) {
+        layout_t *l = event_dispatch_find(block, &layout->children[i]);
+        if (l != NULL) return l;
+    }
+
+    return NULL;
+}
+
 static void event_dispatch_callback(layout_t *layout, event_t event)
 {
     block_event_t event_fn = layout->block->type == BLOCK_SPEC
                            ? ((block_spec_t *)layout->block)->event_fn
                            : NULL;
 
-    log_value_debug("Block received a mouse event",
+    log_value_debug("Block received an event",
                     "s:event", event_type_to_string(event.type),
                     "i:event_x", event.x,
                     "i:event_y", event.y,
@@ -67,19 +85,20 @@ static void event_dispatch_callback(layout_t *layout, event_t event)
     }
 }
 
-static bool event_dispatch_block(layout_t *layout, block_t *block, event_t event)
+static void event_dispatch_callback_block(event_state_t *state, block_t *block, event_t event)
 {
-    if (layout->block == block) {
-        event_dispatch_callback(layout, event);
-        return true;
-    }
+    layout_t tmp = {
+        .block = block,
+    };
 
-    for (int i = 0; i < layout->n_children; i++) {
-        if (event_dispatch_block(&layout->children[i], block, event))
-            return true;
-    }
+    // XXX: As a workaround we are making a mock layout when we have to update an hidden block
+    //      Fix this ugliness please
+    //
+    layout_t *l = block->hidden
+                ? &tmp
+                : event_dispatch_find(block, state->layout);
 
-    return false;
+    event_dispatch_callback(l, event);
 }
 
 static bool event_dispatch_mouse(event_state_t *state, layout_t *layout, event_t event)
@@ -90,18 +109,34 @@ static bool event_dispatch_mouse(event_state_t *state, layout_t *layout, event_t
     if (!check_capsule(event.x, event.y, layout->x, layout->y, width, height))
         return false;
 
-    for (int i = 0; i < layout->n_children; i++) {
+    for (size_t i = 0; i < layout->n_children; i++) {
         if (event_dispatch_mouse(state, &layout->children[i], event))
             return true;
     }
 
     if (event_is_hover(event)) {
-        if (layout->block != state->hovered) {
-            event.type = EVENT_HOVER_STOP;
-            event_dispatch_block(state->layout, state->hovered, event);
+        // Compare only the part related to position and size
+        //
+        bool update = !memcmp(&state->hovered, layout, offsetof(layout_t, line_width))
+                   && event.x == state->hover_x
+                   && event.y == state->hover_y;
+
+        state->hover_x = event.x;
+        state->hover_y = event.y;
+
+        if (layout->block != state->hovered.block) {
+            if (state->hovered.block != NULL) {
+                event.type = EVENT_HOVER_STOP;
+                event_dispatch_callback_block(state, state->hovered.block, event);
+            }
 
             event.type = EVENT_HOVER_START;
-            state->hovered = layout->block;
+            memcpy(&state->hovered, layout, sizeof(layout_t));
+
+        } else if (update) {
+            // Ignore a move with equal cursor position
+            //
+            return true;
         }
     }
 
@@ -111,6 +146,18 @@ static bool event_dispatch_mouse(event_state_t *state, layout_t *layout, event_t
 
 void event_dispatch(event_state_t *state, window_t *window)
 {
+    // Check last cursor position again
+    //
+    if (state->hovered.block != NULL) {
+        event_t event = {
+            .type = EVENT_HOVER_MOVE,
+            .x = state->hover_x,
+            .y = state->hover_y,
+        };
+
+        event_dispatch_mouse(state, state->layout, event);
+    }
+
     xcb_generic_event_t *xevent;
     xcb_motion_notify_event_t *motion = NULL;
 
@@ -139,20 +186,17 @@ void event_dispatch(event_state_t *state, window_t *window)
             }
 
             case XCB_EXPOSE: {
-                xcb_expose_event_t *expose = (xcb_expose_event_t *)xevent;
+                //xcb_expose_event_t *expose = (xcb_expose_event_t *)xevent;
                 log_trace("Processing 'Expose' event");
 
-                // Redraw
-                (void)expose;
+                // XXX: Redraw when rendering ondemand
                 break;
             }
 
             case XCB_CREATE_NOTIFY: {
-                xcb_create_notify_event_t *create = (xcb_create_notify_event_t *)xevent;
+                //xcb_create_notify_event_t *create = (xcb_create_notify_event_t *)xevent;
                 log_trace("Processing 'CreateNotify' event");
 
-                (void)create;
-
                 if (window->cw_params.override_redirect) break;
                 xcb_circulate_window(window->display->connection, XCB_CIRCULATE_RAISE_LOWEST, window->window);
                 break;
@@ -163,16 +207,16 @@ void event_dispatch(event_state_t *state, window_t *window)
                 log_trace("Processing 'LeaveNotify' event");
 
                 if (leave->event != window->window) break;
-                if (state->hovered == NULL) break;
+                if (state->hovered.block == NULL) break;
 
                 event_t event = {
+                    .type = EVENT_HOVER_STOP,
                     .x = leave->event_x,
                     .y = leave->event_y,
-                    .type = EVENT_HOVER_STOP,
                 };
 
-                event_dispatch_block(state->layout, state->hovered, event);
-                state->hovered = NULL;
+                event_dispatch_callback_block(state, state->hovered.block, event);
+                memset(&state->hovered, 0, sizeof(layout_t));
 
                 if (motion != NULL && motion->time <= leave->time) {
                     log_trace("Suppressed older 'MotionNotify' event");
@@ -193,10 +237,11 @@ void event_dispatch(event_state_t *state, window_t *window)
                     break;
                 }
 
+                // NOTE: The order of event_type_t is important!
                 event_t event = {
+                    .type = button->detail,
                     .x = button->event_x,
                     .y = button->event_y,
-                    .type = button->detail,
                 };
 
                 event_dispatch_mouse(state, state->layout, event);
@@ -210,7 +255,8 @@ void event_dispatch(event_state_t *state, window_t *window)
                 if (property->atom == XCB_ATOM_RESOURCE_MANAGER) {
                     display_update_xrm(window->display);
                     display_update_scale(window->display);
-                    // Redraw
+
+                    // XXX: Redraw when rendering ondemand
                 }
                 break;
             }
@@ -243,9 +289,9 @@ void event_dispatch(event_state_t *state, window_t *window)
         log_trace("Processing 'MotionNotify' event");
 
         event_t event = {
+            .type = EVENT_HOVER_MOVE,
             .x = motion->event_x,
             .y = motion->event_y,
-            .type = EVENT_HOVER_MOVE,
         };
 
         event_dispatch_mouse(state, state->layout, event);
diff --git a/src/event.h b/src/event.h
index 68fb507..40424b7 100644
--- a/src/event.h
+++ b/src/event.h
@@ -2,6 +2,7 @@
 #define COMET_EVENT_H
 
 #include "window.h"
+#include "layout.h"
 
 typedef struct layout layout_t;
 
@@ -23,17 +24,21 @@ typedef struct {
 } event_t;
 
 typedef struct {
-    block_t *hovered;
+    layout_t hovered;
     int hover_x, hover_y;
     layout_t *layout;
 } event_state_t;
 
 const char *event_type_to_string(event_type_t type);
 
+bool event_is_trigger(event_t event);
+
 bool event_is_click(event_t event);
 
 bool event_is_scroll(event_t event);
 
+bool event_is_hover(event_t event);
+
 void event_dispatch(event_state_t *state, window_t *window);
 
 #endif
diff --git a/src/layout.c b/src/layout.c
index 103153a..23b15ff 100644
--- a/src/layout.c
+++ b/src/layout.c
@@ -10,7 +10,6 @@
 void layout_init(layout_t *layout, block_t *block, layout_info_t info)
 {
     memset(layout, 0, sizeof(layout_t));
-
     assert(!block->hidden);
 
     layout->block = block;