Drew DeVault
9 years ago
commit
4b48a8399a
@ -0,0 +1,185 @@
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
#include "ipc-client.h"
|
||||
#include "list.h"
|
||||
#include "log.h"
|
||||
#include "ipc.h"
|
||||
#include "render.h"
|
||||
#include "config.h"
|
||||
#include "status_line.h"
|
||||
#include "bar.h"
|
||||
|
||||
static void bar_init(struct bar *bar) {
|
||||
bar->config = init_config();
|
||||
bar->status = init_status_line();
|
||||
bar->output = malloc(sizeof(struct output));
|
||||
bar->output->window = NULL;
|
||||
bar->output->registry = NULL;
|
||||
bar->output->workspaces = create_list();
|
||||
bar->output->name = NULL;
|
||||
}
|
||||
|
||||
static void spawn_status_cmd_proc(struct bar *bar) {
|
||||
if (bar->config->status_command) {
|
||||
int pipefd[2];
|
||||
pipe(pipefd);
|
||||
bar->status_command_pid = fork();
|
||||
if (bar->status_command_pid == 0) {
|
||||
close(pipefd[0]);
|
||||
dup2(pipefd[1], STDOUT_FILENO);
|
||||
close(pipefd[1]);
|
||||
char *const cmd[] = {
|
||||
"sh",
|
||||
"-c",
|
||||
bar->config->status_command,
|
||||
NULL,
|
||||
};
|
||||
execvp(cmd[0], cmd);
|
||||
return;
|
||||
}
|
||||
|
||||
close(pipefd[1]);
|
||||
bar->status_read_fd = pipefd[0];
|
||||
fcntl(bar->status_read_fd, F_SETFL, O_NONBLOCK);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void bar_setup(struct bar *bar, const char *socket_path, const char *bar_id, int desired_output) {
|
||||
/* initialize bar with default values */
|
||||
bar_init(bar);
|
||||
|
||||
bar->output->registry = registry_poll();
|
||||
|
||||
if (!bar->output->registry->desktop_shell) {
|
||||
sway_abort("swaybar requires the compositor to support the desktop-shell extension.");
|
||||
}
|
||||
|
||||
/* connect to sway ipc */
|
||||
bar->ipc_socketfd = ipc_open_socket(socket_path);
|
||||
bar->ipc_event_socketfd = ipc_open_socket(socket_path);
|
||||
|
||||
ipc_bar_init(bar, desired_output, bar_id);
|
||||
|
||||
struct output_state *output = bar->output->registry->outputs->items[desired_output];
|
||||
|
||||
bar->output->window = window_setup(bar->output->registry, output->width, 30, false);
|
||||
if (!bar->output->window) {
|
||||
sway_abort("Failed to create window.");
|
||||
}
|
||||
desktop_shell_set_panel(bar->output->registry->desktop_shell, output->output, bar->output->window->surface);
|
||||
desktop_shell_set_panel_position(bar->output->registry->desktop_shell, bar->config->position);
|
||||
|
||||
/* set font */
|
||||
bar->output->window->font = bar->config->font;
|
||||
|
||||
/* set window height */
|
||||
set_window_height(bar->output->window, bar->config->height);
|
||||
|
||||
/* spawn status command */
|
||||
spawn_status_cmd_proc(bar);
|
||||
}
|
||||
|
||||
void bar_run(struct bar *bar) {
|
||||
fd_set readfds;
|
||||
int activity;
|
||||
bool dirty = true;
|
||||
|
||||
while (1) {
|
||||
if (dirty) {
|
||||
struct output *output = bar->output;
|
||||
if (window_prerender(output->window) && output->window->cairo) {
|
||||
render(output, bar->config, bar->status);
|
||||
window_render(output->window);
|
||||
if (wl_display_dispatch(output->registry->display) == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dirty = false;
|
||||
FD_ZERO(&readfds);
|
||||
FD_SET(bar->ipc_event_socketfd, &readfds);
|
||||
FD_SET(bar->status_read_fd, &readfds);
|
||||
|
||||
activity = select(FD_SETSIZE, &readfds, NULL, NULL, NULL);
|
||||
if (activity < 0) {
|
||||
sway_log(L_ERROR, "polling failed: %d", errno);
|
||||
}
|
||||
|
||||
if (FD_ISSET(bar->ipc_event_socketfd, &readfds)) {
|
||||
sway_log(L_DEBUG, "Got IPC event.");
|
||||
dirty = handle_ipc_event(bar);
|
||||
}
|
||||
|
||||
if (bar->config->status_command && FD_ISSET(bar->status_read_fd, &readfds)) {
|
||||
sway_log(L_DEBUG, "Got update from status command.");
|
||||
dirty = handle_status_line(bar);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void free_workspaces(list_t *workspaces) {
|
||||
int i;
|
||||
for (i = 0; i < workspaces->length; ++i) {
|
||||
struct workspace *ws = workspaces->items[i];
|
||||
free(ws->name);
|
||||
free(ws);
|
||||
}
|
||||
list_free(workspaces);
|
||||
}
|
||||
|
||||
static void free_output(struct output *output) {
|
||||
window_teardown(output->window);
|
||||
if (output->registry) {
|
||||
registry_teardown(output->registry);
|
||||
}
|
||||
|
||||
free(output->name);
|
||||
|
||||
if (output->workspaces) {
|
||||
free_workspaces(output->workspaces);
|
||||
}
|
||||
|
||||
free(output);
|
||||
}
|
||||
|
||||
static void terminate_status_command(pid_t pid) {
|
||||
if (pid) {
|
||||
// terminate status_command process
|
||||
int ret = kill(pid, SIGTERM);
|
||||
if (ret != 0) {
|
||||
sway_log(L_ERROR, "Unable to terminate status_command [pid: %d]", pid);
|
||||
} else {
|
||||
int status;
|
||||
waitpid(pid, &status, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void bar_teardown(struct bar *bar) {
|
||||
free_config(bar->config);
|
||||
free_output(bar->output);
|
||||
free_status_line(bar->status);
|
||||
|
||||
/* close sockets/pipes */
|
||||
if (bar->status_read_fd) {
|
||||
close(bar->status_read_fd);
|
||||
}
|
||||
|
||||
if (bar->ipc_socketfd) {
|
||||
close(bar->ipc_socketfd);
|
||||
}
|
||||
|
||||
if (bar->ipc_event_socketfd) {
|
||||
close(bar->ipc_event_socketfd);
|
||||
}
|
||||
|
||||
/* terminate status command process */
|
||||
terminate_status_command(bar->status_command_pid);
|
||||
}
|
||||
@ -0,0 +1,55 @@
|
||||
#ifndef _SWAYBAR_BAR_H
|
||||
#define _SWAYBAR_BAR_H
|
||||
|
||||
#include "client/registry.h"
|
||||
#include "client/window.h"
|
||||
#include "list.h"
|
||||
|
||||
struct bar {
|
||||
struct config *config;
|
||||
struct status_line *status;
|
||||
struct output *output;
|
||||
/* list_t *outputs; */
|
||||
|
||||
int ipc_event_socketfd;
|
||||
int ipc_socketfd;
|
||||
int status_read_fd;
|
||||
pid_t status_command_pid;
|
||||
};
|
||||
|
||||
struct output {
|
||||
struct window *window;
|
||||
struct registry *registry;
|
||||
list_t *workspaces;
|
||||
char *name;
|
||||
};
|
||||
|
||||
struct workspace {
|
||||
int num;
|
||||
char *name;
|
||||
bool focused;
|
||||
bool visible;
|
||||
bool urgent;
|
||||
};
|
||||
|
||||
/**
|
||||
* Setup bar.
|
||||
*/
|
||||
void bar_setup(struct bar *bar, const char *socket_path, const char *bar_id, int desired_output);
|
||||
|
||||
/**
|
||||
* Bar mainloop.
|
||||
*/
|
||||
void bar_run(struct bar *bar);
|
||||
|
||||
/**
|
||||
* free workspace list.
|
||||
*/
|
||||
void free_workspaces(list_t *workspaces);
|
||||
|
||||
/**
|
||||
* Teardown bar.
|
||||
*/
|
||||
void bar_teardown(struct bar *bar);
|
||||
|
||||
#endif /* _SWAYBAR_BAR_H */
|
||||
@ -0,0 +1,92 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "wayland-desktop-shell-client-protocol.h"
|
||||
#include "log.h"
|
||||
#include "config.h"
|
||||
|
||||
uint32_t parse_color(const char *color) {
|
||||
if (color[0] != '#') {
|
||||
sway_log(L_DEBUG, "Invalid color %s, defaulting to color 0xFFFFFFFF", color);
|
||||
return 0xFFFFFFFF;
|
||||
}
|
||||
char *end;
|
||||
uint32_t res = (uint32_t)strtol(color + 1, &end, 16);
|
||||
if (strlen(color) == 7) {
|
||||
res = (res << 8) | 0xFF;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
uint32_t parse_position(const char *position) {
|
||||
if (strcmp("top", position) == 0) {
|
||||
return DESKTOP_SHELL_PANEL_POSITION_TOP;
|
||||
} else if (strcmp("bottom", position) == 0) {
|
||||
return DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
|
||||
} else if (strcmp("left", position) == 0) {
|
||||
return DESKTOP_SHELL_PANEL_POSITION_LEFT;
|
||||
} else if (strcmp("right", position) == 0) {
|
||||
return DESKTOP_SHELL_PANEL_POSITION_RIGHT;
|
||||
} else {
|
||||
return DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
|
||||
}
|
||||
}
|
||||
|
||||
char *parse_font(const char *font) {
|
||||
char *new_font = NULL;
|
||||
if (strncmp("pango:", font, 6) == 0) {
|
||||
new_font = strdup(font + 6);
|
||||
}
|
||||
|
||||
return new_font;
|
||||
}
|
||||
|
||||
struct config *init_config() {
|
||||
struct config *config = calloc(1, sizeof(struct config));
|
||||
config->status_command = NULL;
|
||||
config->position = DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
|
||||
config->font = strdup("monospace 10");
|
||||
config->mode = NULL;
|
||||
config->sep_symbol = NULL;
|
||||
config->strip_workspace_numbers = false;
|
||||
config->binding_mode_indicator = true;
|
||||
config->workspace_buttons = true;
|
||||
|
||||
/* height */
|
||||
config->height = 0;
|
||||
|
||||
/* colors */
|
||||
config->colors.background = 0x000000FF;
|
||||
config->colors.statusline = 0xFFFFFFFF;
|
||||
config->colors.separator = 0x666666FF;
|
||||
|
||||
config->colors.focused_workspace.border = 0x4C7899FF;
|
||||
config->colors.focused_workspace.background = 0x285577FF;
|
||||
config->colors.focused_workspace.text = 0xFFFFFFFF;
|
||||
|
||||
config->colors.active_workspace.border = 0x333333FF;
|
||||
config->colors.active_workspace.background = 0x5F676AFF;
|
||||
config->colors.active_workspace.text = 0xFFFFFFFF;
|
||||
|
||||
config->colors.inactive_workspace.border = 0x333333FF;
|
||||
config->colors.inactive_workspace.background = 0x222222FF;
|
||||
config->colors.inactive_workspace.text = 0x888888FF;
|
||||
|
||||
config->colors.urgent_workspace.border = 0x2F343AFF;
|
||||
config->colors.urgent_workspace.background = 0x900000FF;
|
||||
config->colors.urgent_workspace.text = 0xFFFFFFFF;
|
||||
|
||||
config->colors.binding_mode.border = 0x2F343AFF;
|
||||
config->colors.binding_mode.background = 0x900000FF;
|
||||
config->colors.binding_mode.text = 0xFFFFFFFF;
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
void free_config(struct config *config) {
|
||||
free(config->status_command);
|
||||
free(config->font);
|
||||
free(config->mode);
|
||||
free(config->sep_symbol);
|
||||
free(config);
|
||||
}
|
||||
@ -0,0 +1,69 @@
|
||||
#ifndef _SWAYBAR_CONFIG_H
|
||||
#define _SWAYBAR_CONFIG_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
/**
|
||||
* Colors for a box with background, border and text colors.
|
||||
*/
|
||||
struct box_colors {
|
||||
uint32_t border;
|
||||
uint32_t background;
|
||||
uint32_t text;
|
||||
};
|
||||
|
||||
/**
|
||||
* Swaybar config.
|
||||
*/
|
||||
struct config {
|
||||
char *status_command;
|
||||
uint32_t position;
|
||||
char *font;
|
||||
char *sep_symbol;
|
||||
char *mode;
|
||||
bool strip_workspace_numbers;
|
||||
bool binding_mode_indicator;
|
||||
bool workspace_buttons;
|
||||
|
||||
int height;
|
||||
|
||||
struct {
|
||||
uint32_t background;
|
||||
uint32_t statusline;
|
||||
uint32_t separator;
|
||||
|
||||
struct box_colors focused_workspace;
|
||||
struct box_colors active_workspace;
|
||||
struct box_colors inactive_workspace;
|
||||
struct box_colors urgent_workspace;
|
||||
struct box_colors binding_mode;
|
||||
} colors;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parse colors defined as hex string to uint32_t.
|
||||
*/
|
||||
uint32_t parse_color(const char *color);
|
||||
|
||||
/**
|
||||
* Parse position top|bottom|left|right.
|
||||
*/
|
||||
uint32_t parse_position(const char *position);
|
||||
|
||||
/**
|
||||
* Parse font.
|
||||
*/
|
||||
char *parse_font(const char *font);
|
||||
|
||||
/**
|
||||
* Initialize default sway config.
|
||||
*/
|
||||
struct config *init_config();
|
||||
|
||||
/**
|
||||
* Free config struct.
|
||||
*/
|
||||
void free_config(struct config *config);
|
||||
|
||||
#endif /* _SWAYBAR_CONFIG_H */
|
||||
@ -0,0 +1,258 @@
|
||||
#include <string.h>
|
||||
#include <json-c/json.h>
|
||||
|
||||
#include "ipc-client.h"
|
||||
#include "list.h"
|
||||
#include "log.h"
|
||||
#include "config.h"
|
||||
#include "ipc.h"
|
||||
|
||||
static void ipc_parse_config(struct config *config, const char *payload) {
|
||||
json_object *bar_config = json_tokener_parse(payload);
|
||||
json_object *tray_output, *mode, *hidden_bar, *position, *status_command;
|
||||
json_object *font, *bar_height, *workspace_buttons, *strip_workspace_numbers;
|
||||
json_object *binding_mode_indicator, *verbose, *colors, *sep_symbol;
|
||||
json_object_object_get_ex(bar_config, "tray_output", &tray_output);
|
||||
json_object_object_get_ex(bar_config, "mode", &mode);
|
||||
json_object_object_get_ex(bar_config, "hidden_bar", &hidden_bar);
|
||||
json_object_object_get_ex(bar_config, "position", &position);
|
||||
json_object_object_get_ex(bar_config, "status_command", &status_command);
|
||||
json_object_object_get_ex(bar_config, "font", &font);
|
||||
json_object_object_get_ex(bar_config, "bar_height", &bar_height);
|
||||
json_object_object_get_ex(bar_config, "workspace_buttons", &workspace_buttons);
|
||||
json_object_object_get_ex(bar_config, "strip_workspace_numbers", &strip_workspace_numbers);
|
||||
json_object_object_get_ex(bar_config, "binding_mode_indicator", &binding_mode_indicator);
|
||||
json_object_object_get_ex(bar_config, "verbose", &verbose);
|
||||
json_object_object_get_ex(bar_config, "separator_symbol", &sep_symbol);
|
||||
json_object_object_get_ex(bar_config, "colors", &colors);
|
||||
|
||||
if (status_command) {
|
||||
free(config->status_command);
|
||||
config->status_command = strdup(json_object_get_string(status_command));
|
||||
}
|
||||
|
||||
if (position) {
|
||||
config->position = parse_position(json_object_get_string(position));
|
||||
}
|
||||
|
||||
if (font) {
|
||||
free(config->font);
|
||||
config->font = parse_font(json_object_get_string(font));
|
||||
}
|
||||
|
||||
if (sep_symbol) {
|
||||
free(config->sep_symbol);
|
||||
config->sep_symbol = strdup(json_object_get_string(sep_symbol));
|
||||
}
|
||||
|
||||
if (strip_workspace_numbers) {
|
||||
config->strip_workspace_numbers = json_object_get_boolean(strip_workspace_numbers);
|
||||
}
|
||||
|
||||
if (binding_mode_indicator) {
|
||||
config->binding_mode_indicator = json_object_get_boolean(binding_mode_indicator);
|
||||
}
|
||||
|
||||
if (workspace_buttons) {
|
||||
config->workspace_buttons = json_object_get_boolean(workspace_buttons);
|
||||
}
|
||||
|
||||
if (bar_height) {
|
||||
config->height = json_object_get_int(bar_height);
|
||||
}
|
||||
|
||||
if (colors) {
|
||||
json_object *background, *statusline, *separator;
|
||||
json_object *focused_workspace_border, *focused_workspace_bg, *focused_workspace_text;
|
||||
json_object *inactive_workspace_border, *inactive_workspace_bg, *inactive_workspace_text;
|
||||
json_object *active_workspace_border, *active_workspace_bg, *active_workspace_text;
|
||||
json_object *urgent_workspace_border, *urgent_workspace_bg, *urgent_workspace_text;
|
||||
json_object *binding_mode_border, *binding_mode_bg, *binding_mode_text;
|
||||
json_object_object_get_ex(colors, "background", &background);
|
||||
json_object_object_get_ex(colors, "statusline", &statusline);
|
||||
json_object_object_get_ex(colors, "separator", &separator);
|
||||
json_object_object_get_ex(colors, "focused_workspace_border", &focused_workspace_border);
|
||||
json_object_object_get_ex(colors, "focused_workspace_bg", &focused_workspace_bg);
|
||||
json_object_object_get_ex(colors, "focused_workspace_text", &focused_workspace_text);
|
||||
json_object_object_get_ex(colors, "active_workspace_border", &active_workspace_border);
|
||||
json_object_object_get_ex(colors, "active_workspace_bg", &active_workspace_bg);
|
||||
json_object_object_get_ex(colors, "active_workspace_text", &active_workspace_text);
|
||||
json_object_object_get_ex(colors, "inactive_workspace_border", &inactive_workspace_border);
|
||||
json_object_object_get_ex(colors, "inactive_workspace_bg", &inactive_workspace_bg);
|
||||
json_object_object_get_ex(colors, "inactive_workspace_text", &inactive_workspace_text);
|
||||
json_object_object_get_ex(colors, "urgent_workspace_border", &urgent_workspace_border);
|
||||
json_object_object_get_ex(colors, "urgent_workspace_bg", &urgent_workspace_bg);
|
||||
json_object_object_get_ex(colors, "urgent_workspace_text", &urgent_workspace_text);
|
||||
json_object_object_get_ex(colors, "binding_mode_border", &binding_mode_border);
|
||||
json_object_object_get_ex(colors, "binding_mode_bg", &binding_mode_bg);
|
||||
json_object_object_get_ex(colors, "binding_mode_text", &binding_mode_text);
|
||||
if (background) {
|
||||
config->colors.background = parse_color(json_object_get_string(background));
|
||||
}
|
||||
|
||||
if (statusline) {
|
||||
config->colors.statusline = parse_color(json_object_get_string(statusline));
|
||||
}
|
||||
|
||||
if (separator) {
|
||||
config->colors.separator = parse_color(json_object_get_string(separator));
|
||||
}
|
||||
|
||||
if (focused_workspace_border) {
|
||||
config->colors.focused_workspace.border = parse_color(json_object_get_string(focused_workspace_border));
|
||||
}
|
||||
|
||||
if (focused_workspace_bg) {
|
||||
config->colors.focused_workspace.background = parse_color(json_object_get_string(focused_workspace_bg));
|
||||
}
|
||||
|
||||
if (focused_workspace_text) {
|
||||
config->colors.focused_workspace.text = parse_color(json_object_get_string(focused_workspace_text));
|
||||
}
|
||||
|
||||
if (active_workspace_border) {
|
||||
config->colors.active_workspace.border = parse_color(json_object_get_string(active_workspace_border));
|
||||
}
|
||||
|
||||
if (active_workspace_bg) {
|
||||
config->colors.active_workspace.background = parse_color(json_object_get_string(active_workspace_bg));
|
||||
}
|
||||
|
||||
if (active_workspace_text) {
|
||||
config->colors.active_workspace.text = parse_color(json_object_get_string(active_workspace_text));
|
||||
}
|
||||
|
||||
if (inactive_workspace_border) {
|
||||
config->colors.inactive_workspace.border = parse_color(json_object_get_string(inactive_workspace_border));
|
||||
}
|
||||
|
||||
if (inactive_workspace_bg) {
|
||||
config->colors.inactive_workspace.background = parse_color(json_object_get_string(inactive_workspace_bg));
|
||||
}
|
||||
|
||||
if (inactive_workspace_text) {
|
||||
config->colors.inactive_workspace.text = parse_color(json_object_get_string(inactive_workspace_text));
|
||||
}
|
||||
|
||||
if (binding_mode_border) {
|
||||
config->colors.binding_mode.border = parse_color(json_object_get_string(binding_mode_border));
|
||||
}
|
||||
|
||||
if (binding_mode_bg) {
|
||||
config->colors.binding_mode.background = parse_color(json_object_get_string(binding_mode_bg));
|
||||
}
|
||||
|
||||
if (binding_mode_text) {
|
||||
config->colors.binding_mode.text = parse_color(json_object_get_string(binding_mode_text));
|
||||
}
|
||||
}
|
||||
|
||||
json_object_put(bar_config);
|
||||
}
|
||||
|
||||
static void ipc_update_workspaces(struct bar *bar) {
|
||||
if (bar->output->workspaces) {
|
||||
free_workspaces(bar->output->workspaces);
|
||||
}
|
||||
bar->output->workspaces = create_list();
|
||||
|
||||
uint32_t len = 0;
|
||||
char *res = ipc_single_command(bar->ipc_socketfd, IPC_GET_WORKSPACES, NULL, &len);
|
||||
json_object *results = json_tokener_parse(res);
|
||||
if (!results) {
|
||||
free(res);
|
||||
return;
|
||||
}
|
||||
|
||||
int i;
|
||||
int length = json_object_array_length(results);
|
||||
json_object *ws_json;
|
||||
json_object *num, *name, *visible, *focused, *out, *urgent;
|
||||
for (i = 0; i < length; ++i) {
|
||||
ws_json = json_object_array_get_idx(results, i);
|
||||
|
||||
json_object_object_get_ex(ws_json, "num", &num);
|
||||
json_object_object_get_ex(ws_json, "name", &name);
|
||||
json_object_object_get_ex(ws_json, "visible", &visible);
|
||||
json_object_object_get_ex(ws_json, "focused", &focused);
|
||||
json_object_object_get_ex(ws_json, "output", &out);
|
||||
json_object_object_get_ex(ws_json, "urgent", &urgent);
|
||||
|
||||
if (strcmp(json_object_get_string(out), bar->output->name) == 0) {
|
||||
struct workspace *ws = malloc(sizeof(struct workspace));
|
||||
ws->num = json_object_get_int(num);
|
||||
ws->name = strdup(json_object_get_string(name));
|
||||
ws->visible = json_object_get_boolean(visible);
|
||||
ws->focused = json_object_get_boolean(focused);
|
||||
ws->urgent = json_object_get_boolean(urgent);
|
||||
list_add(bar->output->workspaces, ws);
|
||||
}
|
||||
}
|
||||
|
||||
json_object_put(results);
|
||||
free(res);
|
||||
}
|
||||
|
||||
void ipc_bar_init(struct bar *bar, int outputi, const char *bar_id) {
|
||||
uint32_t len = 0;
|
||||
char *res = ipc_single_command(bar->ipc_socketfd, IPC_GET_OUTPUTS, NULL, &len);
|
||||
json_object *outputs = json_tokener_parse(res);
|
||||
json_object *info = json_object_array_get_idx(outputs, outputi);
|
||||
json_object *name;
|
||||
json_object_object_get_ex(info, "name", &name);
|
||||
bar->output->name = strdup(json_object_get_string(name));
|
||||
free(res);
|
||||
json_object_put(outputs);
|
||||
|
||||
len = strlen(bar_id);
|
||||
res = ipc_single_command(bar->ipc_socketfd, IPC_GET_BAR_CONFIG, bar_id, &len);
|
||||
|
||||
ipc_parse_config(bar->config, res);
|
||||
free(res);
|
||||
|
||||
const char *subscribe_json = "[ \"workspace\", \"mode\" ]";
|
||||
len = strlen(subscribe_json);
|
||||
res = ipc_single_command(bar->ipc_event_socketfd, IPC_SUBSCRIBE, subscribe_json, &len);
|
||||
free(res);
|
||||
|
||||
ipc_update_workspaces(bar);
|
||||
}
|
||||
|
||||
bool handle_ipc_event(struct bar *bar) {
|
||||
struct ipc_response *resp = ipc_recv_response(bar->ipc_event_socketfd);
|
||||
switch (resp->type) {
|
||||
case IPC_EVENT_WORKSPACE:
|
||||
ipc_update_workspaces(bar);
|
||||
break;
|
||||
case IPC_EVENT_MODE: {
|
||||
json_object *result = json_tokener_parse(resp->payload);
|
||||
if (!result) {
|
||||
free_ipc_response(resp);
|
||||
sway_log(L_ERROR, "failed to parse payload as json");
|
||||
return false;
|
||||
}
|
||||
json_object *json_change;
|
||||
if (json_object_object_get_ex(result, "change", &json_change)) {
|
||||
const char *change = json_object_get_string(json_change);
|
||||
|
||||
free(bar->config->mode);
|
||||
if (strcmp(change, "default") == 0) {
|
||||
bar->config->mode = NULL;
|
||||
} else {
|
||||
bar->config->mode = strdup(change);
|
||||
}
|
||||
} else {
|
||||
sway_log(L_ERROR, "failed to parse response");
|
||||
}
|
||||
|
||||
json_object_put(result);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
free_ipc_response(resp);
|
||||
return false;
|
||||
}
|
||||
|
||||
free_ipc_response(resp);
|
||||
return true;
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef _SWAYBAR_IPC_H
|
||||
#define _SWAYBAR_IPC_H
|
||||
|
||||
#include "bar.h"
|
||||
|
||||
/**
|
||||
* Initialize ipc connection to sway and get sway state, outputs, bar_config.
|
||||
*/
|
||||
void ipc_bar_init(struct bar *bar, int outputi, const char *bar_id);
|
||||
|
||||
/**
|
||||
* Handle ipc event from sway.
|
||||
*/
|
||||
bool handle_ipc_event(struct bar *bar);
|
||||
|
||||
#endif /* _SWAYBAR_IPC_H */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,328 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "client/pango.h"
|
||||
#include "client/window.h"
|
||||
#include "config.h"
|
||||
#include "status_line.h"
|
||||
#include "render.h"
|
||||
|
||||
|
||||
/* internal spacing */
|
||||
static int margin = 3;
|
||||
static int ws_horizontal_padding = 5;
|
||||
static double ws_vertical_padding = 1.5;
|
||||
static int ws_spacing = 1;
|
||||
|
||||
static void cairo_set_source_u32(cairo_t *cairo, uint32_t color) {
|
||||
cairo_set_source_rgba(cairo,
|
||||
((color & 0xFF000000) >> 24) / 256.0,
|
||||
((color & 0xFF0000) >> 16) / 256.0,
|
||||
((color & 0xFF00) >> 8) / 256.0,
|
||||
(color & 0xFF) / 256.0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders a sharp line of any width and height.
|
||||
*
|
||||
* The line is drawn from (x,y) to (x+width,y+height) where width/height is 0
|
||||
* if the line has a width/height of one pixel, respectively.
|
||||
*/
|
||||
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 void render_block(struct window *window, struct config *config, struct status_block *block, double *x, bool edge) {
|
||||
int width, height, sep_width;
|
||||
get_text_size(window, &width, &height, "%s", block->full_text);
|
||||
|
||||
int textwidth = width;
|
||||
double block_width = width;
|
||||
|
||||
if (width < block->min_width) {
|
||||
width = block->min_width;
|
||||
}
|
||||
|
||||
*x -= width;
|
||||
|
||||
if (block->border != 0 && block->border_left > 0) {
|
||||
*x -= (block->border_left + margin);
|
||||
block_width += block->border_left + margin;
|
||||
}
|
||||
|
||||
if (block->border != 0 && block->border_right > 0) {
|
||||
*x -= (block->border_right + margin);
|
||||
block_width += block->border_right + margin;
|
||||
}
|
||||
|
||||
// Add separator
|
||||
if (!edge) {
|
||||
if (config->sep_symbol) {
|
||||
get_text_size(window, &sep_width, &height, "%s", config->sep_symbol);
|
||||
if (sep_width > block->separator_block_width) {
|
||||
block->separator_block_width = sep_width + margin * 2;
|
||||
}
|
||||
}
|
||||
|
||||
*x -= block->separator_block_width;
|
||||
} else {
|
||||
*x -= margin;
|
||||
}
|
||||
|
||||
double pos = *x;
|
||||
|
||||
// render background
|
||||
if (block->background != 0x0) {
|
||||
cairo_set_source_u32(window->cairo, block->background);
|
||||
cairo_rectangle(window->cairo, pos - 0.5, 1, block_width, window->height - 2);
|
||||
cairo_fill(window->cairo);
|
||||
}
|
||||
|
||||
// render top border
|
||||
if (block->border != 0 && block->border_top > 0) {
|
||||
render_sharp_line(window->cairo, block->border,
|
||||
pos - 0.5,
|
||||
1,
|
||||
block_width,
|
||||
block->border_top);
|
||||
}
|
||||
|
||||
// render bottom border
|
||||
if (block->border != 0 && block->border_bottom > 0) {
|
||||
render_sharp_line(window->cairo, block->border,
|
||||
pos - 0.5,
|
||||
window->height - 1 - block->border_bottom,
|
||||
block_width,
|
||||
block->border_bottom);
|
||||
}
|
||||
|
||||
// render left border
|
||||
if (block->border != 0 && block->border_left > 0) {
|
||||
render_sharp_line(window->cairo, block->border,
|
||||
pos - 0.5,
|
||||
1,
|
||||
block->border_left,
|
||||
window->height - 2);
|
||||
|
||||
pos += block->border_left + margin;
|
||||
}
|
||||
|
||||
// render text
|
||||
double offset = 0;
|
||||
|
||||
if (strncmp(block->align, "left", 5) == 0) {
|
||||
offset = pos;
|
||||
} else if (strncmp(block->align, "right", 5) == 0) {
|
||||
offset = pos + width - textwidth;
|
||||
} else if (strncmp(block->align, "center", 6) == 0) {
|
||||
offset = pos + (width - textwidth) / 2;
|
||||
}
|
||||
|
||||
cairo_move_to(window->cairo, offset, margin);
|
||||
cairo_set_source_u32(window->cairo, block->color);
|
||||
pango_printf(window, "%s", block->full_text);
|
||||
|
||||
pos += width;
|
||||
|
||||
// render right border
|
||||
if (block->border != 0 && block->border_right > 0) {
|
||||
pos += margin;
|
||||
|
||||
render_sharp_line(window->cairo, block->border,
|
||||
pos - 0.5,
|
||||
1,
|
||||
block->border_right,
|
||||
window->height - 2);
|
||||
|
||||
pos += block->border_right;
|
||||
}
|
||||
|
||||
// render separator
|
||||
if (!edge && block->separator) {
|
||||
cairo_set_source_u32(window->cairo, config->colors.separator);
|
||||
if (config->sep_symbol) {
|
||||
offset = pos + (block->separator_block_width - sep_width) / 2;
|
||||
cairo_move_to(window->cairo, offset, margin);
|
||||
pango_printf(window, "%s", config->sep_symbol);
|
||||
} else {
|
||||
cairo_set_line_width(window->cairo, 1);
|
||||
cairo_move_to(window->cairo, pos + block->separator_block_width/2,
|
||||
margin);
|
||||
cairo_line_to(window->cairo, pos + block->separator_block_width/2,
|
||||
window->height - margin);
|
||||
cairo_stroke(window->cairo);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static char *handle_workspace_number(bool strip_num, const char *ws_name) {
|
||||
bool strip = false;
|
||||
int i;
|
||||
|
||||
if (strip_num) {
|
||||
int len = strlen(ws_name);
|
||||
for (i = 0; i < len; ++i) {
|
||||
if (!('0' <= ws_name[i] && ws_name[i] <= '9')) {
|
||||
if (':' == ws_name[i] && i < len-1 && i > 0) {
|
||||
strip = true;
|
||||
++i;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (strip) {
|
||||
return strdup(ws_name + i);
|
||||
}
|
||||
|
||||
return strdup(ws_name);
|
||||
}
|
||||
|
||||
static void render_workspace_button(struct window *window, struct config *config, struct workspace *ws, double *x) {
|
||||
// strip workspace numbers if required
|
||||
char *name = handle_workspace_number(config->strip_workspace_numbers, ws->name);
|
||||
|
||||
int width, height;
|
||||
get_text_size(window, &width, &height, "%s", name);
|
||||
struct box_colors box_colors;
|
||||
if (ws->urgent) {
|
||||
box_colors = config->colors.urgent_workspace;
|
||||
} else if (ws->focused) {
|
||||
box_colors = config->colors.focused_workspace;
|
||||
} else if (ws->visible) {
|
||||
box_colors = config->colors.active_workspace;
|
||||
} else {
|
||||
box_colors = config->colors.inactive_workspace;
|
||||
}
|
||||
|
||||
// background
|
||||
cairo_set_source_u32(window->cairo, box_colors.background);
|
||||
cairo_rectangle(window->cairo, *x, 1.5, width + ws_horizontal_padding * 2 - 1,
|
||||
height + ws_vertical_padding * 2);
|
||||
cairo_fill(window->cairo);
|
||||
|
||||
// border
|
||||
cairo_set_source_u32(window->cairo, box_colors.border);
|
||||
cairo_rectangle(window->cairo, *x, 1.5, width + ws_horizontal_padding * 2 - 1,
|
||||
height + ws_vertical_padding * 2);
|
||||
cairo_stroke(window->cairo);
|
||||
|
||||
// text
|
||||
cairo_set_source_u32(window->cairo, box_colors.text);
|
||||
cairo_move_to(window->cairo, (int)*x + ws_horizontal_padding, margin);
|
||||
pango_printf(window, "%s", name);
|
||||
|
||||
*x += width + ws_horizontal_padding * 2 + ws_spacing;
|
||||
|
||||
free(name);
|
||||
}
|
||||
|
||||
static void render_binding_mode_indicator(struct window *window, struct config *config, double pos) {
|
||||
int width, height;
|
||||
get_text_size(window, &width, &height, "%s", config->mode);
|
||||
|
||||
// background
|
||||
cairo_set_source_u32(window->cairo, config->colors.binding_mode.background);
|
||||
cairo_rectangle(window->cairo, pos, 1.5, width + ws_horizontal_padding * 2 - 1,
|
||||
height + ws_vertical_padding * 2);
|
||||
cairo_fill(window->cairo);
|
||||
|
||||
// border
|
||||
cairo_set_source_u32(window->cairo, config->colors.binding_mode.border);
|
||||
cairo_rectangle(window->cairo, pos, 1.5, width + ws_horizontal_padding * 2 - 1,
|
||||
height + ws_vertical_padding * 2);
|
||||
cairo_stroke(window->cairo);
|
||||
|
||||
// text
|
||||
cairo_set_source_u32(window->cairo, config->colors.binding_mode.text);
|
||||
cairo_move_to(window->cairo, (int)pos + ws_horizontal_padding, margin);
|
||||
pango_printf(window, "%s", config->mode);
|
||||
}
|
||||
|
||||
void render(struct output *output, struct config *config, struct status_line *line) {
|
||||
int i;
|
||||
|
||||
struct window *window = output->window;
|
||||
cairo_t *cairo = window->cairo;
|
||||
|
||||
// Clear
|
||||
cairo_save(cairo);
|
||||
cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR);
|
||||
cairo_paint(cairo);
|
||||
cairo_restore(cairo);
|
||||
|
||||
// Background
|
||||
cairo_set_source_u32(cairo, config->colors.background);
|
||||
cairo_paint(cairo);
|
||||
|
||||
// Command output
|
||||
cairo_set_source_u32(cairo, config->colors.statusline);
|
||||
int width, height;
|
||||
|
||||
if (line->protocol == TEXT) {
|
||||
get_text_size(window, &width, &height, "%s", line->text_line);
|
||||
cairo_move_to(cairo, window->width - margin - width, margin);
|
||||
pango_printf(window, "%s", line);
|
||||
} else if (line->protocol == I3BAR && line->block_line) {
|
||||
double pos = window->width - 0.5;
|
||||
bool edge = true;
|
||||
for (i = line->block_line->length - 1; i >= 0; --i) {
|
||||
struct status_block *block = line->block_line->items[i];
|
||||
if (block->full_text && block->full_text[0]) {
|
||||
render_block(window, config, block, &pos, edge);
|
||||
edge = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cairo_set_line_width(cairo, 1.0);
|
||||
double x = 0.5;
|
||||
|
||||
// Workspaces
|
||||
if (config->workspace_buttons) {
|
||||
for (i = 0; i < output->workspaces->length; ++i) {
|
||||
struct workspace *ws = output->workspaces->items[i];
|
||||
render_workspace_button(window, config, ws, &x);
|
||||
}
|
||||
}
|
||||
|
||||
// binding mode indicator
|
||||
if (config->mode && config->binding_mode_indicator) {
|
||||
render_binding_mode_indicator(window, config, x);
|
||||
}
|
||||
}
|
||||
|
||||
void set_window_height(struct window *window, int height) {
|
||||
int text_width, text_height;
|
||||
get_text_size(window, &text_width, &text_height, "Test string for measuring purposes");
|
||||
if (height > 0) {
|
||||
margin = (height - text_height) / 2;
|
||||
ws_vertical_padding = margin - 1.5;
|
||||
}
|
||||
window->height = text_height + margin * 2;
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef _SWAYBAR_RENDER_H
|
||||
#define _SWAYBAR_RENDER_H
|
||||
|
||||
#include "config.h"
|
||||
#include "bar.h"
|
||||
|
||||
/**
|
||||
* Render swaybar.
|
||||
*/
|
||||
void render(struct output *output, struct config *config, struct status_line *line);
|
||||
|
||||
/**
|
||||
* Set window height and modify internal spacing accordingly.
|
||||
*/
|
||||
void set_window_height(struct window *window, int height);
|
||||
|
||||
#endif /* _SWAYBAR_RENDER_H */
|
||||
@ -0,0 +1,442 @@
|
||||
#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 bar[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 bar *bar, 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 (bar->status->block_line) {
|
||||
list_foreach(bar->status->block_line, free_status_block);
|
||||
list_free(bar->status->block_line);
|
||||
}
|
||||
|
||||
bar->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 = bar->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(bar->status->block_line, new);
|
||||
}
|
||||
|
||||
json_object_put(results);
|
||||
}
|
||||
|
||||
// continue parsing from last parserpos
|
||||
static int i3json_parse(struct bar *bar) {
|
||||
char *c = i3json_state.parserpos;
|
||||
int handled = 0;
|
||||
while (*c) {
|
||||
if (i3json_state.bar[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.bar[i3json_state.depth] = I3JSON_ARRAY;
|
||||
if (i3json_state.depth == 2) {
|
||||
i3json_state.line_start = c;
|
||||
}
|
||||
break;
|
||||
case ']':
|
||||
if (i3json_state.bar[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(bar, 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.bar[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 bar *bar, char *data) {
|
||||
int len = strlen(data);
|
||||
i3json_ensure_free(len);
|
||||
strcpy(i3json_state.parserpos, data);
|
||||
return i3json_parse(bar);
|
||||
}
|
||||
|
||||
// read data from fd and parse it.
|
||||
static int i3json_handle_fd(struct bar *bar) {
|
||||
i3json_ensure_free(10240);
|
||||
// get fresh data at the end of the buffer
|
||||
int readlen = read(bar->status_read_fd, i3json_state.parserpos, 10239);
|
||||
if (readlen < 0) {
|
||||
return readlen;
|
||||
}
|
||||
i3json_state.parserpos[readlen] = '\0';
|
||||
return i3json_parse(bar);
|
||||
}
|
||||
|
||||
bool handle_status_line(struct bar *bar) {
|
||||
bool dirty = false;
|
||||
|
||||
switch (bar->status->protocol) {
|
||||
case I3BAR:
|
||||
sway_log(L_DEBUG, "Got i3bar protocol.");
|
||||
if (i3json_handle_fd(bar) > 0) {
|
||||
dirty = true;
|
||||
}
|
||||
break;
|
||||
case TEXT:
|
||||
sway_log(L_DEBUG, "Got text protocol.");
|
||||
read_line_tail(bar->status_read_fd, line, sizeof(line), line_rest);
|
||||
dirty = true;
|
||||
bar->status->text_line = line;
|
||||
break;
|
||||
case UNDEF:
|
||||
sway_log(L_DEBUG, "Detecting protocol...");
|
||||
if (read_line_tail(bar->status_read_fd, line, sizeof(line), line_rest) < 0) {
|
||||
break;
|
||||
}
|
||||
dirty = true;
|
||||
bar->status->text_line = line;
|
||||
bar->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.");
|
||||
bar->status->protocol = I3BAR;
|
||||
i3json_handle_data(bar, 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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
#ifndef _SWAYBAR_STATUS_LINE_H
|
||||
#define _SWAYBAR_STATUS_LINE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "list.h"
|
||||
#include "bar.h"
|
||||
|
||||
typedef enum {UNDEF, TEXT, I3BAR} command_protocol;
|
||||
|
||||
struct status_line {
|
||||
list_t *block_line;
|
||||
const char *text_line;
|
||||
command_protocol protocol;
|
||||
};
|
||||
|
||||
struct status_block {
|
||||
char *full_text, *short_text, *align;
|
||||
bool urgent;
|
||||
uint32_t color;
|
||||
int min_width;
|
||||
char *name, *instance;
|
||||
bool separator;
|
||||
int separator_block_width;
|
||||
// Airblader features
|
||||
uint32_t background;
|
||||
uint32_t border;
|
||||
int border_top;
|
||||
int border_bottom;
|
||||
int border_left;
|
||||
int border_right;
|
||||
};
|
||||
|
||||
/**
|
||||
* Initialize status line struct.
|
||||
*/
|
||||
struct status_line *init_status_line();
|
||||
|
||||
/**
|
||||
* handle status line activity.
|
||||
*/
|
||||
bool handle_status_line(struct bar *bar);
|
||||
|
||||
/**
|
||||
* Free status line struct.
|
||||
*/
|
||||
void free_status_line(struct status_line *line);
|
||||
|
||||
#endif /* _SWAYBAR_STATUS_LINE_H */
|
||||
Loading…
Reference in new issue