Refactor

8 files changed, 80 insertions, 54 deletions

diff --git a/src/block.c b/src/block.c
index 442e753..3d558d1 100644
--- a/src/block.c
+++ b/src/block.c
@@ -10,9 +10,11 @@ void block_update(block_t *block)
         diff = timespec_diff(block->update_last, now);
 
         if (timespec_greater(diff, block->update_interval)) {
+            log_value_debug("Updating block",
+                            "s:label", block->label);
+
             block->update_cb(block);
             block->update_last = now;
-            log_debug("Updated block");
         }
     }
 
diff --git a/src/block.h b/src/block.h
index 8a91bf3..1a91596 100644
--- a/src/block.h
+++ b/src/block.h
@@ -51,6 +51,7 @@ struct block {
     struct timespec update_last;
     block_update_t update_cb;
     block_event_t event_cb;
+    const char *label;
     block_type_t type;
     union {
         struct {
diff --git a/src/comet.c b/src/comet.c
index 7e3f12c..e87836e 100644
--- a/src/comet.c
+++ b/src/comet.c
@@ -8,6 +8,7 @@
 #include "event.h"
 
 #define ANY_LOG_IMPLEMENT
+#define ANY_LOG_VALUE_STRING(key, value) "%s=\"%s\"", key, value ? value : "(null)"
 #include "any_log.h"
 
 cairo_surface_t *render(layout_t *layout, layout_info_t info)
@@ -86,7 +87,7 @@ int main(int argc, char **argv)
     block_t top = {
         .hidden = false,
         .color = { 0.3, 0.2, 0.5, 1 },
-        .min_width = 1000,
+        .min_width = width,
         .type = BLOCK_GROUP,
         .group = {
             .spacing = 10,
@@ -96,14 +97,12 @@ int main(int argc, char **argv)
     };
 
     // TODO: Allow ondemand rendering
+    struct timespec rate, start, end, diff;
 
     double freq = 1.0 / 60.0 + 0.5e-9;
-    struct timespec rate;
     rate.tv_sec = (long)freq;
     rate.tv_nsec = (freq - rate.tv_sec) * 1000000000ul;
 
-    struct timespec start, end, diff;
-
     while (true) {
         timespec_get(&start, TIME_UTC);
 
diff --git a/src/event.c b/src/event.c
index 9e65a9e..4f5a73f 100644
--- a/src/event.c
+++ b/src/event.c
@@ -1,32 +1,51 @@
+#include <assert.h>
+
 #include "util.h"
 #include "layout.h"
 #include "event.h"
 #include "any_log.h"
 
-bool event_dispatch_block(layout_t *layout, event_t event)
+const char *even_type_to_string(event_type_t type)
+{
+    const char *types[] = {
+        "left_click",
+        "middle_click",
+        "right_click",
+        "trigger",
+    };
+
+    assert(type >= EVENT_LEFT_CLICK && type <= EVENT_TRIGGER);
+    return types[type];
+}
+
+static bool event_click(layout_t *layout, event_t event)
 {
     int width  = layout->width  - 2 * layout->x_padding;
     int height = layout->height - 2 * layout->y_padding;
 
-    if (!in_capsule(event.x, event.y, layout->x, layout->y, width, height))
+    if (!check_capsule(event.x, event.y, layout->x, layout->y, width, height))
         return false;
 
     for (int i = 0; i < layout->n_children; i++) {
-        if (event_dispatch_block(&layout->children[i], event))
+        if (event_click(&layout->children[i], event))
             return true;
     }
 
-    log_value_trace("Event targeted a block",
-                    "i:event_x", event.x,
-                    "i:event_y", event.y,
-                    "i:x", layout->x,
-                    "i:y", layout->y,
-                    "i:width", layout->width,
-                    "i:height", layout->height);
-
-    if (layout->block->event_cb != NULL) {
-        layout->block->event_cb(layout->block, event);
-        log_debug("Called event callback");
+    block_event_t event_cb = layout->block->event_cb;
+    log_value_debug("Block was clicked",
+                    "s:type", even_type_to_string(event.type),
+                    "i:x", event.x,
+                    "i:y", event.y,
+                    "s:block_label", layout->block->label,
+                    "i:block_x", layout->x,
+                    "i:block_y", layout->y,
+                    "i:block_width", layout->width,
+                    "i:block_height", layout->height,
+                    "b:callback", event_cb != NULL);
+
+    if (event_cb != NULL) {
+        event_cb(layout->block, event);
+        log_trace("Completed event callback");
     }
 
     return true;
@@ -87,18 +106,18 @@ void event_dispatch(display_t *display, layout_t *layout)
 
                 switch (button->detail) {
                     case XCB_BUTTON_INDEX_1:
-                        event.type = EVENT_RIGHT_CLICK;
-                        event_dispatch_block(layout, event);
+                        event.type = EVENT_LEFT_CLICK;
+                        event_click(layout, event);
                         break;
 
                     case XCB_BUTTON_INDEX_2:
-                        event.type = EVENT_LEFT_CLICK;
-                        event_dispatch_block(layout, event);
+                        event.type = EVENT_MIDDLE_CLICK;
+                        event_click(layout, event);
                         break;
 
                     case XCB_BUTTON_INDEX_3:
-                        event.type = EVENT_MIDDLE_CLICK;
-                        event_dispatch_block(layout, event);
+                        event.type = EVENT_RIGHT_CLICK;
+                        event_click(layout, event);
                         break;
 
                     default:
diff --git a/src/event.h b/src/event.h
index 609458a..528482d 100644
--- a/src/event.h
+++ b/src/event.h
@@ -17,6 +17,8 @@ typedef struct {
 
 typedef struct layout layout_t;
 
+const char *even_type_to_string(event_type_t type);
+
 void event_dispatch(display_t *display, layout_t *layout);
 
 #endif
diff --git a/src/util.c b/src/util.c
index 075c55c..288fab6 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <stdio.h>
 
 #include "util.h"
 
@@ -18,18 +19,35 @@ bool timespec_greater(struct timespec a, struct timespec b)
         || (a.tv_sec == b.tv_sec && a.tv_nsec > b.tv_nsec);
 }
 
-bool in_capsule(int px, int py, int x, int y, int w, int h)
+void timespec_print(struct timespec *ts)
+{
+    printf("%ld.%.9ld", ts->tv_sec, ts->tv_nsec);
+}
+
+bool check_rect(int px, int py, int x, int y, int w, int h)
+{
+    return px >= x && px <= x + w && py >= y && py <= y + h;
+}
+
+bool check_circle(int px, int py, int x, int y, int r)
+{
+    int dx = x - px;
+    int dy = y - py;
+    return (dx * dx + dy * dy) <= r * r;
+}
+
+bool check_capsule(int px, int py, int x, int y, int w, int h)
 {
     assert(w >= h);
     int radius = h / 2;
 
     // Trivial case
     if (w == h)
-        return in_circle(px, py, x + radius, y + radius, radius);
+        return check_circle(px, py, x + radius, y + radius, radius);
 
     // General case
-    return in_circle(px, py, x + radius, y + radius, radius)
-        || in_circle(px, py, x + w - radius, y + radius, radius)
-        || in_rect(px, py, x + radius, y, w - 2 * radius, h);
+    return check_circle(px, py, x + radius, y + radius, radius)
+        || check_circle(px, py, x + w - radius, y + radius, radius)
+        || check_rect(px, py, x + radius, y, w - 2 * radius, h);
 }
 
diff --git a/src/util.h b/src/util.h
index 9e84a7c..5e661a3 100644
--- a/src/util.h
+++ b/src/util.h
@@ -9,21 +9,15 @@ struct timespec timespec_diff(struct timespec a, struct timespec b);
 
 bool timespec_greater(struct timespec a, struct timespec b);
 
+void timespec_print(struct timespec *ts);
+
 // Check if point (px, py) is inside a rectangle in (x, y), (x+w, y), (x, y+h) and (w+h, y+h)
-static inline bool in_rect(int px, int py, int x, int y, int w, int h)
-{
-    return px >= x && px <= x + w && py >= y && py <= y + h;
-}
+bool check_rect(int px, int py, int x, int y, int w, int h);
 
 // Check if point (px, py) is inside a circle of radius r and center (x, y)
-static inline bool in_circle(int px, int py, int x, int y, int r)
-{
-    int dx = x - px;
-    int dy = y - py;
-    return (dx * dx + dy * dy) <= r * r;
-}
+bool check_circle(int px, int py, int x, int y, int r);
 
 // Check if point (px, py) is inside a capsule in (x, y), (x+w, y), (x, y+h) and (w+h, y+h)
-bool in_capsule(int px, int py, int x, int y, int w, int h);
+bool check_capsule(int px, int py, int x, int y, int w, int h);
 
 #endif
diff --git a/src/window.c b/src/window.c
index 0dba42f..55ebfe2 100644
--- a/src/window.c
+++ b/src/window.c
@@ -70,7 +70,7 @@ static void wm_set_struts(window_t *window)
                         12,
                         values);
 
-    log_trace("Xcb EWMH struts updated");
+    log_trace("EWMH struts updated");
 }
 
 static void wm_setup(window_t *window)
@@ -85,13 +85,6 @@ static void wm_setup(window_t *window)
                     "s:title", title,
                     "s:class", "comet\\0Comet");
 
-    xcb_generic_error_t *error;
-    xcb_intern_atom_cookie_t *ewmh_cookie = xcb_ewmh_init_atoms(window->display->connection, &window->display->ewmh);
-
-    assert(xcb_ewmh_init_atoms_replies(&window->display->ewmh, ewmh_cookie, &error));
-    assert(error == NULL);
-    log_debug("Connected EWMH");
-
     xcb_ewmh_set_wm_window_type(&window->display->ewmh, window->window, 1, &window->display->ewmh._NET_WM_WINDOW_TYPE_DOCK);
     xcb_ewmh_set_wm_desktop(&window->display->ewmh, window->window, 0xFFFFFFFF);
     xcb_ewmh_set_wm_pid(&window->display->ewmh, window->window, getpid());
@@ -165,11 +158,11 @@ void window_init(window_t *window, display_t *display)
                                                display->screen_size->height);
 
     assert(cairo_surface_status(window->surface) == CAIRO_STATUS_SUCCESS);
-    log_trace("Cairo surface created");
+    log_trace("Created cairo xcb surface");
 
     window->cr = cairo_create(window->surface);
     assert(cairo_status(window->cr) == CAIRO_STATUS_SUCCESS);
-    log_trace("Cairo context created");
+    log_trace("Created cairo window context");
 }
 
 void window_move(window_t *window, int x, int y)
@@ -202,7 +195,7 @@ static void window_reshape(window_t *window)
 
     xcb_pixmap_t bitmap = xcb_generate_id(window->display->connection);
     xcb_create_pixmap(window->display->connection, depth, bitmap, window->window, window->width, window->height);
-    log_trace("Xcb pixmap created");
+    log_trace("Created xcb pixmap");
 
     cairo_surface_t *surface = cairo_xcb_surface_create_for_bitmap(window->display->connection,
                                                                    window->display->screen,
@@ -226,8 +219,6 @@ static void window_reshape(window_t *window)
     cairo_arc(cr, window->width - radius, radius, radius, 270 * degree, 450 * degree);
     cairo_fill(cr);
 
-    log_trace("Painted window shape");
-
     cairo_show_page(cr);
     cairo_destroy(cr);
     cairo_surface_flush(surface);