/*

* i3bar.c - i3bar (plus i3-gaps and sway) protocol support

* Copyright (C) 2014-2019 Vivien Didelot

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "bar.h"

#include "block.h"

#include "json.h"

#include "line.h"

#include "log.h"

#include "map.h"

#include "term.h"

/* See https://i3wm.org/docs/i3bar-protocol.html for details */

static struct {

const char * const key;

bool string;

} i3bar_keys[] = {

{ "", false }, /* unknown key */

/* Standard keys */

{ "full_text", true },

{ "short_text", true },

{ "color", true },

{ "background", true },

{ "border", true },

{ "min_width", false }, /* can also be a number */

{ "align", true },

{ "name", true },

{ "instance", true },

{ "urgent", false },

{ "separator", false },

{ "separator_block_width", false },

{ "markup", true },

/* i3-gaps features */

{ "border_top", false },

{ "border_bottom", false },

{ "border_left", false },

{ "border_right", false },

};

static unsigned int i3bar_indexof(const char *key)

{

unsigned int i;

for (i = 0; i < sizeof(i3bar_keys) / sizeof(i3bar_keys[0]); i )

if (strcmp(i3bar_keys[i].key, key) == 0)

return i;

return 0;

}

static int i3bar_line_cb(char *line, size_t num, void *data)

{

unsigned int index = num 1;

struct map *map = data;

const char *key;

if (index >= sizeof(i3bar_keys) / sizeof(i3bar_keys[0])) {

debug("ignoring excess line %d: %s", num, line);

return 0;

}

key = i3bar_keys[index].key;

return map_set(map, key, line);

}

int i3bar_read(int fd, size_t count, struct map *map)

{

return line_read(fd, count, i3bar_line_cb, map);

}

static void i3bar_print_term(const struct bar *bar)

{

struct block *block = bar->blocks;

const char *full_text;

term_restore_cursor();

while (block) {

full_text = map_get(block->env, "full_text");

if (full_text)

fprintf(stdout, "%s ", full_text);

block = block->next;

}

fflush(stdout);

}

static int i3bar_print_pair(const char *key, const char *value, void *data)

{

unsigned int index = i3bar_indexof(key);

bool string = i3bar_keys[index].string;

unsigned int *pcount = data;

char buf[BUFSIZ];

bool escape;

int err;

/* Skip unknown keys */

if (!index)

return 0;

if (!value)

value = "null";

if (string) {

if (json_is_string(value))

escape = false; /* Expected string already quoted */

else

escape = true; /* Enforce the string type */

} else {

if (json_is_valid(value))

escape = false; /* Already valid JSON */

else

escape = true; /* Unquoted string */

}

if (escape) {

err = json_escape(value, buf, sizeof(buf));

if (err)

return err;

value = buf;

}

if ((*pcount) )

fprintf(stdout, ",");

fprintf(stdout, "\"%s\":%s", key, value);

return 0;

}

static int i3bar_print_block(struct block *block, void *data)

{

const char *full_text = map_get(block->env, "full_text");

unsigned int *mcount = data;

unsigned int pcount = 0;

int err;

/* "full_text" is the only mandatory key */

if (!full_text) {

block_debug(block, "no text to display, skipping");

return 0;

}

if ((*mcount) )

fprintf(stdout, ",");

fprintf(stdout, "{");

err = map_for_each(block->env, i3bar_print_pair, &pcount);

fprintf(stdout, "}");

return err;

}

int i3bar_print(const struct bar *bar)

{

struct block *block = bar->blocks;

unsigned int mcount = 0;

int err;

if (bar->term) {

i3bar_print_term(bar);

return 0;

}

fprintf(stdout, ",[");

while (block) {

err = i3bar_print_block(block, &mcount);

if (err)

break;

block = block->next;

}

fprintf(stdout, "]\n");

fflush(stdout);

return err;

}

int i3bar_printf(struct block *block, int lvl, const char *msg)

{

const struct bar *bar = block->bar;

struct map *map = block->env;

int err;

if (bar->term || lvl > LOG_ERROR)

return 0;

block->tainted = true;

err = map_set(map, "full_text", msg);

if (err)

return err;

if (lvl <= LOG_ERROR) {

err = map_set(map, "urgent", "true");

if (err)

return err;

}

return i3bar_print(bar);

}

int i3bar_start(struct bar *bar)

{

if (bar->term) {

term_save_cursor();

term_restore_cursor();

} else {

fprintf(stdout, "{\"version\":1,\"click_events\":true}\n[[]\n");

fflush(stdout);

}

return 0;

}

void i3bar_stop(struct bar *bar)

{

if (bar->term) {

term_reset_cursor();

} else {

fprintf(stdout, "]\n");

fflush(stdout);

}

}

static struct block *i3bar_find(struct bar *bar, const struct map *map)

{

const char *block_name, *block_instance;

const char *map_name, *map_instance;

struct block *block = bar->blocks;

/* "name" and "instance" are the only identifiers provided by i3bar */

map_name = map_get(map, "name") ? : "";

map_instance = map_get(map, "instance") ? : "";

while (block) {

block_name = block_get(block, "name") ? : "";

block_instance = block_get(block, "instance") ? : "";

if (strcmp(block_name, map_name) == 0 &&

strcmp(block_instance, map_instance) == 0)

return block;

block = block->next;

}

return NULL;

}

int i3bar_click(struct bar *bar)

{

struct block *block;

struct map *click;

int err;

click = map_create();

if (!click)

return -ENOMEM;

for (;;) {

/* Each click is one JSON object per line */

err = json_read(STDIN_FILENO, 1, click);

if (err) {

if (err == -EAGAIN)

err = 0;

break;

}

/* Look for the corresponding block */

block = i3bar_find(bar, click);

if (block) {

if (block->tainted) {

err = block_reset(block);

if (err)

break;

block->tainted = false;

err = i3bar_print(bar);

if (err)

break;

} else {

err = map_copy(block->env, click);

if (err)

break;

err = block_click(block);

if (err)

break;

}

}

map_clear(click);

}

map_destroy(click);

return err;

}

int i3bar_setup(struct block *block)

{

const char *instance = map_get(block->config, "instance");

const char *name = map_get(block->config, "name");

char buf[BUFSIZ];

int err;

/* A block needs a name to be clickable */

if (!name) {

name = "foo";

err = map_set(block->config, "name", name);

if (err)

return err;

}

if (instance)

snprintf(buf, sizeof(buf), "%s:%s", name, instance);

else

snprintf(buf, sizeof(buf), "%s", name);

block->name = strdup(buf);

if (!block->name)

return -ENOMEM;

return 0;

}