sway/swaybar/status_line.c

531 lines
14 KiB
C
Raw Normal View History

#define _XOPEN_SOURCE 700
2016-01-23 20:55:01 +01:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <json-c/json.h>
2016-09-01 14:18:37 +02:00
#include "swaybar/config.h"
#include "swaybar/status_line.h"
2016-01-23 20:55:01 +01:00
#include "log.h"
#include "util.h"
2016-01-23 20:55:01 +01:00
#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;
2016-01-24 02:34:20 +01:00
int bar[I3JSON_MAXDEPTH+1];
2016-01-23 20:55:01 +01:00
} i3json_state = { 0, NULL, NULL, NULL, false, 0, { I3JSON_UNKNOWN } };
static char line[1024];
static char line_rest[1024];
static char event_buff[1024];
2016-01-23 20:55:01 +01:00
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);
}
2016-01-24 02:34:20 +01:00
static void parse_json(struct bar *bar, const char *text) {
2016-01-23 20:55:01 +01:00
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;
}
2016-01-24 02:34:20 +01:00
if (bar->status->block_line) {
list_foreach(bar->status->block_line, free_status_block);
list_free(bar->status->block_line);
2016-01-23 20:55:01 +01:00
}
2016-01-24 02:34:20 +01:00
bar->status->block_line = create_list();
2016-01-23 20:55:01 +01:00
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;
2016-04-17 17:35:22 +02:00
json_object *border_left, *border_right, *markup;
2016-01-23 20:55:01 +01:00
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);
2016-04-17 17:35:22 +02:00
json_object_object_get_ex(json, "markup", &markup);
2016-01-23 20:55:01 +01:00
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 {
2016-01-24 02:34:20 +01:00
new->color = bar->config->colors.statusline;
2016-01-23 20:55:01 +01:00
}
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));
}
2016-04-17 17:35:22 +02:00
if (markup) {
new->markup = false;
const char *markup_str = json_object_get_string(markup);
if (strcmp(markup_str, "pango") == 0) {
new->markup = true;
}
2016-04-17 17:35:22 +02:00
}
2016-01-23 20:55:01 +01:00
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;
}
2016-01-24 02:34:20 +01:00
list_add(bar->status->block_line, new);
2016-01-23 20:55:01 +01:00
}
json_object_put(results);
}
// continue parsing from last parserpos
2016-01-24 02:34:20 +01:00
static int i3json_parse(struct bar *bar) {
2016-01-23 20:55:01 +01:00
char *c = i3json_state.parserpos;
int handled = 0;
while (*c) {
2016-01-24 02:34:20 +01:00
if (i3json_state.bar[i3json_state.depth] == I3JSON_STRING) {
2016-01-23 20:55:01 +01:00
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");
}
2016-01-24 02:34:20 +01:00
i3json_state.bar[i3json_state.depth] = I3JSON_ARRAY;
2016-01-23 20:55:01 +01:00
if (i3json_state.depth == 2) {
i3json_state.line_start = c;
}
break;
case ']':
2016-01-24 02:34:20 +01:00
if (i3json_state.bar[i3json_state.depth] != I3JSON_ARRAY) {
2016-01-23 20:55:01 +01:00
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';
2016-01-24 02:34:20 +01:00
parse_json(bar, i3json_state.line_start);
2016-01-23 20:55:01 +01:00
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");
}
2016-01-24 02:34:20 +01:00
i3json_state.bar[i3json_state.depth] = I3JSON_STRING;
2016-01-23 20:55:01 +01:00
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.
2016-01-24 02:34:20 +01:00
static int i3json_handle_data(struct bar *bar, char *data) {
2016-01-23 20:55:01 +01:00
int len = strlen(data);
i3json_ensure_free(len);
strcpy(i3json_state.parserpos, data);
2016-01-24 02:34:20 +01:00
return i3json_parse(bar);
2016-01-23 20:55:01 +01:00
}
// read data from fd and parse it.
2016-01-24 02:34:20 +01:00
static int i3json_handle_fd(struct bar *bar) {
2016-01-23 20:55:01 +01:00
i3json_ensure_free(10240);
// get fresh data at the end of the buffer
2016-01-24 02:34:20 +01:00
int readlen = read(bar->status_read_fd, i3json_state.parserpos, 10239);
2016-01-23 20:55:01 +01:00
if (readlen < 0) {
return readlen;
}
i3json_state.parserpos[readlen] = '\0';
2016-01-24 02:34:20 +01:00
return i3json_parse(bar);
2016-01-23 20:55:01 +01:00
}
bool status_line_mouse_event(struct bar *bar, int x, int y, uint32_t button) {
sway_log(L_DEBUG, "status_line_mouse_event.");
if (!bar->status->click_events) {
sway_log(L_DEBUG, "click_events are not enabled.");
return false;
}
if (bar->status->protocol == I3BAR) {
sway_log(L_DEBUG, "Sending click event.");
// find clicked block
struct status_block *clicked_block = NULL;
struct status_block *current_block = NULL;
int num_blocks = bar->status->block_line->length;
if (num_blocks == 0) {
return false;
2017-08-29 15:55:30 +02:00
} else {
current_block = bar->status->block_line->items[0];
if (x < current_block->x) {
return false;
}
}
for (int i = 0; i < num_blocks; i++) {
current_block = bar->status->block_line->items[i];
if (x < (current_block->x + current_block->width)) {
clicked_block = current_block;
break;
}
}
if (!clicked_block || !clicked_block->name) {
return false;
}
// event example {"name":"capture","instance":"label","button":1,"x":3431,"y":18}
struct json_object *event_json = json_object_new_object();
json_object_object_add(event_json, "name", json_object_new_string(clicked_block->name));
if (clicked_block->instance) {
json_object_object_add(event_json, "instance", json_object_new_string(clicked_block->instance));
}
json_object_object_add(event_json, "button", json_object_new_int(button));
json_object_object_add(event_json, "x", json_object_new_int(x));
json_object_object_add(event_json, "y", json_object_new_int(y));
int len = snprintf(event_buff, sizeof(event_buff), "%s,\n", json_object_to_json_string(event_json));
json_object_put(event_json);
if (len <= (int)sizeof(event_buff)) { // if not truncated
write(bar->status_write_fd, event_buff, len);
return true;
}
}
return false;
}
2016-01-24 02:34:20 +01:00
bool handle_status_line(struct bar *bar) {
2016-01-23 20:55:01 +01:00
bool dirty = false;
2016-01-24 02:34:20 +01:00
switch (bar->status->protocol) {
2016-01-23 20:55:01 +01:00
case I3BAR:
sway_log(L_DEBUG, "Got i3bar protocol.");
2016-01-24 02:34:20 +01:00
if (i3json_handle_fd(bar) > 0) {
2016-01-23 20:55:01 +01:00
dirty = true;
}
break;
case TEXT:
sway_log(L_DEBUG, "Got text protocol.");
2016-01-24 02:34:20 +01:00
read_line_tail(bar->status_read_fd, line, sizeof(line), line_rest);
2016-01-23 20:55:01 +01:00
dirty = true;
2016-01-24 02:34:20 +01:00
bar->status->text_line = line;
2016-01-23 20:55:01 +01:00
break;
case UNDEF:
sway_log(L_DEBUG, "Detecting protocol...");
2016-01-24 02:34:20 +01:00
if (read_line_tail(bar->status_read_fd, line, sizeof(line), line_rest) < 0) {
2016-01-23 20:55:01 +01:00
break;
}
dirty = true;
2016-01-24 02:34:20 +01:00
bar->status->text_line = line;
bar->status->protocol = TEXT;
2016-01-23 20:55:01 +01:00
if (line[0] == '{') {
// detect i3bar json protocol
json_object *proto = json_tokener_parse(line);
if (proto) {
json_object *version;
2016-01-23 20:55:01 +01:00
if (json_object_object_get_ex(proto, "version", &version)
&& json_object_get_int(version) == 1
) {
sway_log(L_DEBUG, "Switched to i3bar protocol.");
2016-01-24 02:34:20 +01:00
bar->status->protocol = I3BAR;
2016-01-23 20:55:01 +01:00
}
json_object *click_events;
if (json_object_object_get_ex(proto, "click_events", &click_events)
2017-08-30 08:16:17 +02:00
&& json_object_get_boolean(click_events)) {
sway_log(L_DEBUG, "Enabling click events.");
bar->status->click_events = true;
const char *events_array = "[\n";
write(bar->status_write_fd, events_array, strlen(events_array));
}
i3json_handle_data(bar, line_rest);
2016-01-23 20:55:01 +01:00
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;
line->click_events = false;
2016-01-23 20:55:01 +01:00
return line;
}
void free_status_line(struct status_line *line) {
if (line->block_line) {
list_foreach(line->block_line, free_status_block);
list_free(line->block_line);
}
}