swaybar: feactor render, statusline

1 files changed, 435 insertions, 0 deletions

diff --git a/swaybar/status_line.c b/swaybar/status_line.c
new file mode 100644
index 00000000..a9ed8d8c
--- /dev/null
+++ b/swaybar/status_line.c
@@ -0,0 +1,435 @@
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <json-c/json.h>
+
+#include "log.h"
+#include "config.h"
+#include "status_line.h"
+
+#define I3JSON_MAXDEPTH 4
+#define I3JSON_UNKNOWN 0
+#define I3JSON_ARRAY 1
+#define I3JSON_STRING 2
+
+struct {
+        int bufsize;
+        char *buffer;
+        char *line_start;
+        char *parserpos;
+        bool escape;
+        int depth;
+        int state[I3JSON_MAXDEPTH+1];
+} i3json_state = { 0, NULL, NULL, NULL, false, 0, { I3JSON_UNKNOWN } };
+
+static char line[1024];
+static char line_rest[1024];
+
+static void free_status_block(void *item) {
+        if (!item) {
+                return;
+        }
+        struct status_block *sb = (struct status_block*)item;
+        if (sb->full_text) {
+                free(sb->full_text);
+        }
+        if (sb->short_text) {
+                free(sb->short_text);
+        }
+        if (sb->align) {
+                free(sb->align);
+        }
+        if (sb->name) {
+                free(sb->name);
+        }
+        if (sb->instance) {
+                free(sb->instance);
+        }
+        free(sb);
+}
+
+static void parse_json(struct swaybar_state *st, const char *text) {
+        json_object *results = json_tokener_parse(text);
+        if (!results) {
+                sway_log(L_DEBUG, "Failed to parse json");
+                return;
+        }
+
+        if (json_object_array_length(results) < 1) {
+                return;
+        }
+
+        if (st->status->block_line) {
+                list_foreach(st->status->block_line, free_status_block);
+                list_free(st->status->block_line);
+        }
+
+        st->status->block_line = create_list();
+
+        int i;
+        for (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;
+
+                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, "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 status_block *new = calloc(1, sizeof(struct status_block));
+
+                if (full_text) {
+                        new->full_text = strdup(json_object_get_string(full_text));
+                }
+
+                if (short_text) {
+                        new->short_text = strdup(json_object_get_string(short_text));
+                }
+
+                if (color) {
+                        new->color = parse_color(json_object_get_string(color));
+                } else {
+                        new->color = st->config->colors.statusline;
+                }
+
+                if (min_width) {
+                        json_type type = json_object_get_type(min_width);
+                        if (type == json_type_int) {
+                                new->min_width = json_object_get_int(min_width);
+                        } else if (type == json_type_string) {
+                                /* the width will be calculated when rendering */
+                                new->min_width = 0;
+                        }
+                }
+
+                if (align) {
+                        new->align = strdup(json_object_get_string(align));
+                } else {
+                        new->align = strdup("left");
+                }
+
+                if (urgent) {
+                        new->urgent = json_object_get_int(urgent);
+                }
+
+                if (name) {
+                        new->name = strdup(json_object_get_string(name));
+                }
+
+                if (instance) {
+                        new->instance = strdup(json_object_get_string(instance));
+                }
+
+                if (separator) {
+                        new->separator = json_object_get_int(separator);
+                } else {
+                        new->separator = true; // i3bar spec
+                }
+
+                if (separator_block_width) {
+                        new->separator_block_width = json_object_get_int(separator_block_width);
+                } else {
+                        new->separator_block_width = 9; // i3bar spec
+                }
+
+                // Airblader features
+                if (background) {
+                        new->background = parse_color(json_object_get_string(background));
+                } else {
+                        new->background = 0x0; // transparent
+                }
+
+                if (border) {
+                        new->border = parse_color(json_object_get_string(border));
+                } else {
+                        new->border = 0x0; // transparent
+                }
+
+                if (border_top) {
+                        new->border_top = json_object_get_int(border_top);
+                } else {
+                        new->border_top = 1;
+                }
+
+                if (border_bottom) {
+                        new->border_bottom = json_object_get_int(border_bottom);
+                } else {
+                        new->border_bottom = 1;
+                }
+
+                if (border_left) {
+                        new->border_left = json_object_get_int(border_left);
+                } else {
+                        new->border_left = 1;
+                }
+
+                if (border_right) {
+                        new->border_right = json_object_get_int(border_right);
+                } else {
+                        new->border_right = 1;
+                }
+
+                list_add(st->status->block_line, new);
+        }
+
+        json_object_put(results);
+}
+
+// continue parsing from last parserpos
+static int i3json_parse(struct swaybar_state *st) {
+        char *c = i3json_state.parserpos;
+        int handled = 0;
+        while (*c) {
+                if (i3json_state.state[i3json_state.depth] == I3JSON_STRING) {
+                        if (!i3json_state.escape && *c == '"') {
+                                --i3json_state.depth;
+                        }
+                        i3json_state.escape = !i3json_state.escape && *c == '\\';
+                } else {
+                        switch (*c) {
+                        case '[':
+                                ++i3json_state.depth;
+                                if (i3json_state.depth > I3JSON_MAXDEPTH) {
+                                        sway_abort("JSON too deep");
+                                }
+                                i3json_state.state[i3json_state.depth] = I3JSON_ARRAY;
+                                if (i3json_state.depth == 2) {
+                                        i3json_state.line_start = c;
+                                }
+                                break;
+                        case ']':
+                                if (i3json_state.state[i3json_state.depth] != I3JSON_ARRAY) {
+                                        sway_abort("JSON malformed");
+                                }
+                                --i3json_state.depth;
+                                if (i3json_state.depth == 1) {
+                                        // c[1] is valid since c[0] != '\0'
+                                        char p = c[1];
+                                        c[1] = '\0';
+                                        parse_json(st, i3json_state.line_start);
+                                        c[1] = p;
+                                        ++handled;
+                                        i3json_state.line_start = c+1;
+                                }
+                                break;
+                        case '"':
+                                ++i3json_state.depth;
+                                if (i3json_state.depth > I3JSON_MAXDEPTH) {
+                                        sway_abort("JSON too deep");
+                                }
+                                i3json_state.state[i3json_state.depth] = I3JSON_STRING;
+                                break;
+                        }
+                }
+                ++c;
+        }
+        i3json_state.parserpos = c;
+        return handled;
+}
+
+// Read line from file descriptor, only show the line tail if it is too long.
+// In non-blocking mode treat "no more data" as a linebreak.
+// If data after a line break has been read, return it in rest.
+// If rest is non-empty, then use that as the start of the next line.
+static int read_line_tail(int fd, char *buf, int nbyte, char *rest) {
+        if (fd < 0 || !buf || !nbyte) {
+                return -1;
+        }
+        int l;
+        char *buffer = malloc(nbyte*2+1);
+        char *readpos = buffer;
+        char *lf;
+        // prepend old data to new line if necessary
+        if (rest) {
+                l = strlen(rest);
+                if (l > nbyte) {
+                        strcpy(buffer, rest + l - nbyte);
+                        readpos += nbyte;
+                } else if (l) {
+                        strcpy(buffer, rest);
+                        readpos += l;
+                }
+        }
+        // read until a linefeed is found or no more data is available
+        while ((l = read(fd, readpos, nbyte)) > 0) {
+                readpos[l] = '\0';
+                lf = strchr(readpos, '\n');
+                if (lf) {
+                        // linefeed found, replace with \0
+                        *lf = '\0';
+                        // give data from the end of the line, try to fill the buffer
+                        if (lf-buffer > nbyte) {
+                                strcpy(buf, lf - nbyte + 1);
+                        } else {
+                                strcpy(buf, buffer);
+                        }
+                        // we may have read data from the next line, save it to rest
+                        if (rest) {
+                                rest[0] = '\0';
+                                strcpy(rest, lf + 1);
+                        }
+                        free(buffer);
+                        return strlen(buf);
+                } else {
+                        // no linefeed found, slide data back.
+                        int overflow = readpos - buffer + l - nbyte;
+                        if (overflow > 0) {
+                                memmove(buffer, buffer + overflow , nbyte + 1);
+                        }
+                }
+        }
+        if (l < 0) {
+                free(buffer);
+                return l;
+        }
+        readpos[l]='\0';
+        if (rest) {
+                rest[0] = '\0';
+        }
+        if (nbyte < readpos - buffer + l - 1) {
+                memcpy(buf, readpos - nbyte + l + 1, nbyte);
+        } else {
+                strncpy(buf, buffer, nbyte);
+        }
+        buf[nbyte-1] = '\0';
+        free(buffer);
+        return strlen(buf);
+}
+
+// make sure that enough buffer space is available starting from parserpos
+static void i3json_ensure_free(int min_free) {
+        int _step = 10240;
+        int r = min_free % _step;
+        if (r) {
+                min_free += _step - r;
+        }
+        if (!i3json_state.buffer) {
+                i3json_state.buffer = malloc(min_free);
+                i3json_state.bufsize = min_free;
+                i3json_state.parserpos = i3json_state.buffer;
+        } else {
+                int len = 0;
+                int pos = 0;
+                if (i3json_state.line_start) {
+                        len = strlen(i3json_state.line_start);
+                        pos = i3json_state.parserpos - i3json_state.line_start;
+                        if (i3json_state.line_start != i3json_state.buffer) {
+                                memmove(i3json_state.buffer, i3json_state.line_start, len+1);
+                        }
+                } else {
+                        len = strlen(i3json_state.buffer);
+                }
+                if (i3json_state.bufsize < len+min_free) {
+                        i3json_state.bufsize += min_free;
+                        if (i3json_state.bufsize > 1024000) {
+                                sway_abort("Status line json too long or malformed.");
+                        }
+                        i3json_state.buffer = realloc(i3json_state.buffer, i3json_state.bufsize);
+                        if (!i3json_state.buffer) {
+                                sway_abort("Could not allocate json buffer");
+                        }
+                }
+                if (i3json_state.line_start) {
+                        i3json_state.line_start = i3json_state.buffer;
+                        i3json_state.parserpos = i3json_state.buffer + pos;
+                } else {
+                        i3json_state.parserpos = i3json_state.buffer;
+                }
+        }
+        if (!i3json_state.buffer) {
+                sway_abort("Could not allocate buffer.");
+        }
+}
+
+// append data and parse it.
+static int i3json_handle_data(struct swaybar_state *st, char *data) {
+        int len = strlen(data);
+        i3json_ensure_free(len);
+        strcpy(i3json_state.parserpos, data);
+        return i3json_parse(st);
+}
+
+// read data from fd and parse it.
+static int i3json_handle_fd(struct swaybar_state *st) {
+        i3json_ensure_free(10240);
+        // get fresh data at the end of the buffer
+        int readlen = read(st->status_read_fd, i3json_state.parserpos, 10239);
+        if (readlen < 0) {
+                return readlen;
+        }
+        i3json_state.parserpos[readlen] = '\0';
+        return i3json_parse(st);
+}
+
+bool handle_status_line(struct swaybar_state *st) {
+        bool dirty = false;
+
+        switch (st->status->protocol) {
+        case I3BAR:
+                sway_log(L_DEBUG, "Got i3bar protocol.");
+                if (i3json_handle_fd(st) > 0) {
+                        dirty = true;
+                }
+                break;
+        case TEXT:
+                sway_log(L_DEBUG, "Got text protocol.");
+                read_line_tail(st->status_read_fd, line, sizeof(line), line_rest);
+                dirty = true;
+                st->status->text_line = line;
+                break;
+        case UNDEF:
+                sway_log(L_DEBUG, "Detecting protocol...");
+                if (read_line_tail(st->status_read_fd, line, sizeof(line), line_rest) < 0) {
+                        break;
+                }
+                dirty = true;
+                st->status->text_line = line;
+                st->status->protocol = TEXT;
+                if (line[0] == '{') {
+                        // detect i3bar json protocol
+                        json_object *proto = json_tokener_parse(line);
+                        json_object *version;
+                        if (proto) {
+                                if (json_object_object_get_ex(proto, "version", &version)
+                                                        && json_object_get_int(version) == 1
+                                ) {
+                                        sway_log(L_DEBUG, "Switched to i3bar protocol.");
+                                        st->status->protocol = I3BAR;
+                                        i3json_handle_data(st, line_rest);
+                                }
+                                json_object_put(proto);
+                        }
+                }
+                break;
+        }
+
+        return dirty;
+}
+
+struct status_line *init_status_line() {
+        struct status_line *line = malloc(sizeof(struct status_line));
+        line->block_line = create_list();
+        line->text_line = NULL;
+        line->protocol = UNDEF;
+
+        return line;
+}