Render i3bar blocks

5 files changed, 310 insertions, 30 deletions

diff --git a/swaybar/bar.c b/swaybar/bar.c
index f743236c..fb417095 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -308,14 +308,14 @@ static void display_in(int fd, short mask, void *_bar) {
 
 static void ipc_in(int fd, short mask, void *_bar) {
         struct swaybar *bar = (struct swaybar *)_bar;
-        if (handle_ipc_event(bar)) {
+        if (handle_ipc_readable(bar)) {
                 render_all_frames(bar);
         }
 }
 
 static void status_in(int fd, short mask, void *_bar) {
         struct swaybar *bar = (struct swaybar *)_bar;
-        if (handle_status_readable(bar->status)) {
+        if (status_handle_readable(bar->status)) {
                 render_all_frames(bar);
         }
 }
diff --git a/swaybar/i3bar.c b/swaybar/i3bar.c
index 5be348b2..41b71164 100644
--- a/swaybar/i3bar.c
+++ b/swaybar/i3bar.c
@@ -1,3 +1,5 @@
+#define _POSIX_C_SOURCE 200809L
+#include <json-c/json.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -5,11 +7,109 @@
 #include "swaybar/config.h"
 #include "swaybar/status_line.h"
 
-static void i3bar_parse_json(struct status_line *status, const char *text) {
-        wlr_log(L_DEBUG, "got json: %s", text);
+static void i3bar_block_free(struct i3bar_block *block) {
+        if (!block) {
+                return;
+        }
+        wl_list_remove(&block->link);
+        free(block->full_text);
+        free(block->short_text);
+        free(block->align);
+        free(block->name);
+        free(block->instance);
+        free(block->color);
+}
+
+static bool i3bar_parse_json(struct status_line *status, const char *text) {
+        struct i3bar_block *block, *tmp;
+        wl_list_for_each_safe(block, tmp, &status->blocks, link) {
+                i3bar_block_free(block);
+        }
+        json_object *results = json_tokener_parse(text);
+        if (!results) {
+                status_error(status, "[failed to parse i3bar json]");
+                return false;
+        }
+        if (json_object_array_length(results) < 1) {
+                return true;
+        }
+        for (size_t i = 0; i < json_object_array_length(results); ++i) {
+                json_object *full_text, *short_text, *color, *min_width, *align, *urgent;
+                json_object *name, *instance, *separator, *separator_block_width;
+                json_object *background, *border, *border_top, *border_bottom;
+                json_object *border_left, *border_right, *markup;
+                json_object *json = json_object_array_get_idx(results, i);
+                if (!json) {
+                        continue;
+                }
+                json_object_object_get_ex(json, "full_text", &full_text);
+                json_object_object_get_ex(json, "short_text", &short_text);
+                json_object_object_get_ex(json, "color", &color);
+                json_object_object_get_ex(json, "min_width", &min_width);
+                json_object_object_get_ex(json, "align", &align);
+                json_object_object_get_ex(json, "urgent", &urgent);
+                json_object_object_get_ex(json, "name", &name);
+                json_object_object_get_ex(json, "instance", &instance);
+                json_object_object_get_ex(json, "markup", &markup);
+                json_object_object_get_ex(json, "separator", &separator);
+                json_object_object_get_ex(json, "separator_block_width", &separator_block_width);
+                json_object_object_get_ex(json, "background", &background);
+                json_object_object_get_ex(json, "border", &border);
+                json_object_object_get_ex(json, "border_top", &border_top);
+                json_object_object_get_ex(json, "border_bottom", &border_bottom);
+                json_object_object_get_ex(json, "border_left", &border_left);
+                json_object_object_get_ex(json, "border_right", &border_right);
+
+                struct i3bar_block *block = calloc(1, sizeof(struct i3bar_block));
+                block->full_text = full_text ?
+                        strdup(json_object_get_string(full_text)) : NULL;
+                block->short_text = short_text ?
+                        strdup(json_object_get_string(short_text)) : NULL;
+                if (color) {
+                        block->color = malloc(sizeof(uint32_t));
+                        *block->color = parse_color(json_object_get_string(color));
+                }
+                if (min_width) {
+                        json_type type = json_object_get_type(min_width);
+                        if (type == json_type_int) {
+                                block->min_width = json_object_get_int(min_width);
+                        } else if (type == json_type_string) {
+                                /* the width will be calculated when rendering */
+                                block->min_width = 0;
+                        }
+                }
+                block->align = strdup(align ? json_object_get_string(align) : "left");
+                block->urgent = urgent ? json_object_get_int(urgent) : false;
+                block->name = name ? strdup(json_object_get_string(name)) : NULL;
+                block->instance = instance ?
+                        strdup(json_object_get_string(instance)) : NULL;
+                if (markup) {
+                        block->markup = false;
+                        const char *markup_str = json_object_get_string(markup);
+                        if (strcmp(markup_str, "pango") == 0) {
+                                block->markup = true;
+                        }
+                }
+                block->separator = separator ? json_object_get_int(separator) : true;
+                block->separator_block_width = separator_block_width ?
+                        json_object_get_int(separator_block_width) : 9;
+                // Airblader features
+                block->background = background ?
+                        parse_color(json_object_get_string(background)) : 0;
+                block->border = border ? 
+                        parse_color(json_object_get_string(border)) : 0;
+                block->border_top = border_top ? json_object_get_int(border_top) : 1;
+                block->border_bottom = border_bottom ?
+                        json_object_get_int(border_bottom) : 1;
+                block->border_left = border_left ? json_object_get_int(border_left) : 1;
+                block->border_right = border_right ?
+                        json_object_get_int(border_right) : 1;
+                wl_list_insert(&status->blocks, &block->link);
+        }
+        return true;
 }
 
-int i3bar_readable(struct status_line *status) {
+bool i3bar_handle_readable(struct status_line *status) {
         struct i3bar_protocol_state *state = &status->i3bar_state;
 
         char *cur = &state->buffer[state->buffer_index];
@@ -30,7 +130,7 @@ int i3bar_readable(struct status_line *status) {
                 state->buffer = new_buffer;
         }
 
-        int handled = 0;
+        bool redraw = false;
         while (*cur) {
                 if (state->nodes[state->depth] == JSON_NODE_STRING) {
                         if (!state->escape && *cur == '"') {
@@ -44,7 +144,7 @@ int i3bar_readable(struct status_line *status) {
                                 if (state->depth >
                                                 sizeof(state->nodes) / sizeof(state->nodes[0])) {
                                         status_error(status, "[i3bar json too deep]");
-                                        return -1;
+                                        return false;
                                 }
                                 state->nodes[state->depth] = JSON_NODE_ARRAY;
                                 if (state->depth == 1) {
@@ -54,18 +154,18 @@ int i3bar_readable(struct status_line *status) {
                         case ']':
                                 if (state->nodes[state->depth] != JSON_NODE_ARRAY) {
                                         status_error(status, "[failed to parse i3bar json]");
-                                        return -1;
+                                        return false;
                                 }
                                 --state->depth;
                                 if (state->depth == 0) {
                                         // cur[1] is valid since cur[0] != '\0'
                                         char p = cur[1];
                                         cur[1] = '\0';
-                                        i3bar_parse_json(status, state->current_node);
+                                        redraw = i3bar_parse_json(
+                                                        status, state->current_node) || redraw;
                                         cur[1] = p;
                                         memmove(state->buffer, cur,
                                                         state->buffer_size - (cur - state->buffer));
-                                        ++handled;
                                         cur = state->buffer;
                                         state->current_node = cur + 1;
                                 }
@@ -75,7 +175,7 @@ int i3bar_readable(struct status_line *status) {
                                 if (state->depth >
                                                 sizeof(state->nodes) / sizeof(state->nodes[0])) {
                                         status_error(status, "[i3bar json too deep]");
-                                        return -1;
+                                        return false;
                                 }
                                 state->nodes[state->depth] = JSON_NODE_STRING;
                                 break;
@@ -84,5 +184,5 @@ int i3bar_readable(struct status_line *status) {
                 ++cur;
         }
         state->buffer_index = cur - state->buffer;
-        return handled;
+        return redraw;
 }
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index 64583df0..ed5d9a31 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -323,7 +323,7 @@ void ipc_initialize(struct swaybar *bar, const char *bar_id) {
                         IPC_SUBSCRIBE, subscribe, &len));
 }
 
-bool handle_ipc_event(struct swaybar *bar) {
+bool handle_ipc_readable(struct swaybar *bar) {
         struct ipc_response *resp = ipc_recv_response(bar->ipc_event_socketfd);
         if (!resp) {
                 return false;
diff --git a/swaybar/render.c b/swaybar/render.c
index c2358724..3ad6d5d7 100644
--- a/swaybar/render.c
+++ b/swaybar/render.c
@@ -18,10 +18,33 @@ static const int ws_horizontal_padding = 5;
 static const double ws_vertical_padding = 1.5;
 static const double border_width = 1;
 
+static uint32_t render_status_line_error(cairo_t *cairo,
+                struct swaybar_config *config, const char *error,
+                double *x, uint32_t width, uint32_t height) {
+        if (!error) {
+                return 0;
+        }
+        cairo_set_source_u32(cairo, 0xFF0000FF);
+        static const int margin = 3;
+        int text_width, text_height;
+        get_text_size(cairo, config->font,
+                        &text_width, &text_height, 1, false, "%s", error);
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2;
+        if (height < ideal_height) {
+                return ideal_height;
+        }
+        *x -= text_width + margin;
+        double text_y = height / 2.0 - text_height / 2.0;
+        cairo_move_to(cairo, *x, (int)floor(text_y));
+        pango_printf(cairo, config->font, 1, false, "%s", error);
+        *x -= margin;
+        return ideal_height;
+}
+
 static uint32_t render_status_line_text(cairo_t *cairo,
-                struct swaybar_config *config, struct status_line *status,
-                bool focused, uint32_t width, uint32_t height) {
-        if (!status->text) {
+                struct swaybar_config *config, const char *text,
+                bool focused, double *x, uint32_t width, uint32_t height) {
+        if (!text) {
                 return 0;
         }
         cairo_set_source_u32(cairo, focused ?
@@ -29,38 +52,193 @@ static uint32_t render_status_line_text(cairo_t *cairo,
         static const int margin = 3;
         int text_width, text_height;
         get_text_size(cairo, config->font, &text_width, &text_height,
-                        1, config->pango_markup, "%s", status->text);
+                        1, config->pango_markup, "%s", text);
         uint32_t ideal_height = text_height + ws_vertical_padding * 2;
         if (height < ideal_height) {
                 return ideal_height;
         }
+        *x -= text_width + margin;
         double text_y = height / 2.0 - text_height / 2.0;
-        cairo_move_to(cairo, width - text_width - margin, (int)floor(text_y));
-        pango_printf(cairo, config->font, 1, config->pango_markup,
-                        "%s", status->text);
+        cairo_move_to(cairo, *x, (int)floor(text_y));
+        pango_printf(cairo, config->font, 1, config->pango_markup, "%s", text);
+        *x -= margin;
+        return ideal_height;
+}
+
+static void render_sharp_line(cairo_t *cairo, uint32_t color,
+                double x, double y, double width, double height) {
+        cairo_set_source_u32(cairo, color);
+        if (width > 1 && height > 1) {
+                cairo_rectangle(cairo, x, y, width, height);
+                cairo_fill(cairo);
+        } else {
+                if (width == 1) {
+                        x += 0.5;
+                        height += y;
+                        width = x;
+                }
+                if (height == 1) {
+                        y += 0.5;
+                        width += x;
+                        height = y;
+                }
+                cairo_move_to(cairo, x, y);
+                cairo_set_line_width(cairo, 1.0);
+                cairo_line_to(cairo, width, height);
+                cairo_stroke(cairo);
+        }
+}
+
+static uint32_t render_status_block(cairo_t *cairo,
+                struct swaybar_config *config, struct i3bar_block *block,
+                double *x, uint32_t height, bool focused, bool edge) {
+        static const int margin = 3;
+        if (!block->full_text || !*block->full_text) {
+                return 0;
+        }
+
+        int text_width, text_height;
+        get_text_size(cairo, config->font, &text_width, &text_height,
+                        1, block->markup, "%s", block->full_text);
+        int width = text_width;
+        if (width < block->min_width) {
+                width = block->min_width;
+        }
+        double block_width = width;
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2;
+        if (height < ideal_height) {
+                return ideal_height;
+        }
+
+        *x -= width;
+        if (block->border && block->border_left > 0) {
+                *x -= (block->border_left + margin);
+                block_width += block->border_left + margin;
+        }
+        if (block->border && block->border_right > 0) {
+                *x -= (block->border_right + margin);
+                block_width += block->border_right + margin;
+        }
+
+        int sep_width;
+        if (!edge) {
+                if (config->sep_symbol) {
+                        int _height;
+                        get_text_size(cairo, config->font, &sep_width, &_height,
+                                        1, false, "%s", config->sep_symbol);
+                        uint32_t _ideal_height = _height + ws_vertical_padding * 2;
+                        if (height < _ideal_height) {
+                                return _height;
+                        }
+                        if (sep_width > block->separator_block_width) {
+                                block->separator_block_width = sep_width + margin * 2;
+                        }
+                }
+                *x -= block->separator_block_width;
+        } else {
+                *x -= margin;
+        }
+
+        // TODO: Create hotspot here
+
+        double pos = *x;
+        if (block->background) {
+                cairo_set_source_u32(cairo, block->background);
+                cairo_rectangle(cairo, pos - 0.5, 1, block_width, height);
+                cairo_fill(cairo);
+        }
+
+        if (block->border && block->border_top > 0) {
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5, 1, block_width, block->border_top);
+        }
+        if (block->border && block->border_bottom > 0) {
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5, height - 1 - block->border_bottom,
+                                block_width, block->border_bottom);
+        }
+        if (block->border != 0 && block->border_left > 0) {
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5, 1, block->border_left, height);
+                pos += block->border_left + margin;
+        }
+
+        double offset = 0;
+        if (strncmp(block->align, "left", 5) == 0) {
+                offset = pos;
+        } else if (strncmp(block->align, "right", 5) == 0) {
+                offset = pos + width - text_width;
+        } else if (strncmp(block->align, "center", 6) == 0) {
+                offset = pos + (width - text_width) / 2;
+        }
+        cairo_move_to(cairo, offset, height / 2.0 - text_height / 2.0);
+        uint32_t color = block->color ?  *block->color : config->colors.statusline;
+        cairo_set_source_u32(cairo, color);
+        pango_printf(cairo, config->font, 1, block->markup, "%s", block->full_text);
+        pos += width;
+
+        if (block->border && block->border_right > 0) {
+                pos += margin;
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5, 1, block->border_right, height);
+                pos += block->border_right;
+        }
+
+        if (!edge && block->separator) {
+                if (focused) {
+                        cairo_set_source_u32(cairo, config->colors.focused_separator);
+                } else {
+                        cairo_set_source_u32(cairo, config->colors.separator);
+                }
+                if (config->sep_symbol) {
+                        offset = pos + (block->separator_block_width - sep_width) / 2;
+                        cairo_move_to(cairo, offset, margin);
+                        pango_printf(cairo, config->font, 1, false,
+                                        "%s", config->sep_symbol);
+                } else {
+                        cairo_set_line_width(cairo, 1);
+                        cairo_move_to(cairo,
+                                        pos + block->separator_block_width / 2, margin);
+                        cairo_line_to(cairo,
+                                        pos + block->separator_block_width / 2, height - margin);
+                        cairo_stroke(cairo);
+                }
+        }
         return ideal_height;
 }
 
 static uint32_t render_status_line_i3bar(cairo_t *cairo,
                 struct swaybar_config *config, struct status_line *status,
-                bool focused, uint32_t width, uint32_t height) {
-        // TODO
-        return 0;
+                bool focused, double *x, uint32_t width, uint32_t height) {
+        struct i3bar_block *block;
+        uint32_t max_height = 0;
+        bool edge = true;
+        wl_list_for_each_reverse(block, &status->blocks, link) {
+                uint32_t h = render_status_block(cairo, config,
+                                block, x, height, focused, edge);
+                max_height = h > max_height ? h : max_height;
+                edge = false;
+        }
+        return max_height;
 }
 
 static uint32_t render_status_line(cairo_t *cairo,
                 struct swaybar_config *config, struct status_line *status,
-                bool focused, uint32_t width, uint32_t height) {
+                bool focused, double *x, uint32_t width, uint32_t height) {
         switch (status->protocol) {
+        case PROTOCOL_ERROR:
+                return render_status_line_error(cairo,
+                                config, status->text, x, width, height);
         case PROTOCOL_TEXT:
                 return render_status_line_text(cairo,
-                                config, status, focused, width, height);
+                                config, status->text, focused, x, width, height);
         case PROTOCOL_I3BAR:
                 return render_status_line_i3bar(cairo,
-                                config, status, focused, width, height);
-        default:
+                                config, status, focused, x, width, height);
+        case PROTOCOL_UNDEF:
                 return 0;
         }
+        return 0;
 }
 
 static uint32_t render_binding_mode_indicator(cairo_t *cairo,
@@ -211,9 +389,10 @@ static uint32_t render_to_cairo(cairo_t *cairo,
                                 cairo, config, config->mode, x, output->height);
                 max_height = h > max_height ? h : max_height;
         }
+        x = output->width;
         if (bar->status) {
                 uint32_t h = render_status_line(cairo, config, bar->status,
-                                output->focused, output->width, output->height);
+                                output->focused, &x, output->width, output->height);
                 max_height = h > max_height ? h : max_height;
         }
 
diff --git a/swaybar/status_line.c b/swaybar/status_line.c
index c94ac6d4..cc7e217f 100644
--- a/swaybar/status_line.c
+++ b/swaybar/status_line.c
@@ -17,13 +17,13 @@ void status_error(struct status_line *status, const char *text) {
         status->text = text;
 }
 
-bool handle_status_readable(struct status_line *status) {
+bool status_handle_readable(struct status_line *status) {
         char *line;
         switch (status->protocol) {
         case PROTOCOL_ERROR:
                 return false;
         case PROTOCOL_I3BAR:
-                if (i3bar_readable(status) > 0) {
+                if (i3bar_handle_readable(status) > 0) {
                         return true;
                 }
                 break;
@@ -66,6 +66,7 @@ bool handle_status_readable(struct status_line *status) {
 
                         status->protocol = PROTOCOL_I3BAR;
                         free(status->text_state.buffer);
+                        wl_list_init(&status->blocks);
                         status->i3bar_state.buffer_size = 4096;
                         status->i3bar_state.buffer =
                                 malloc(status->i3bar_state.buffer_size);