From cab1352801b62d1b8a12ca1c995cb24445ce4bc9 Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Wed, 28 Mar 2018 23:04:20 -0400
Subject: Start port of swaybar to layer shell

This starts up the event loop and wayland display and shims out the
basic top level rendering concepts. Also includes some changes to
incorporate pango into the 1.x codebase properly.
---
 include/swaybar/ipc.h | 22 ++++------------------
 1 file changed, 4 insertions(+), 18 deletions(-)

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index c11931d0..57a1b925 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -1,23 +1,9 @@
 #ifndef _SWAYBAR_IPC_H
 #define _SWAYBAR_IPC_H
+#include "swaybar/bar.h"
 
-#include "bar.h"
-
-/**
- * Initialize ipc connection to sway and get sway state, outputs, bar_config.
- */
-void ipc_bar_init(struct bar *bar, const char *bar_id);
-
-/**
- * Handle ipc event from sway.
- */
-bool handle_ipc_event(struct bar *bar);
-
-
-/**
- * Send workspace command to sway
- */
+void ipc_bar_init(struct swaybar *bar, const char *bar_id);
+bool handle_ipc_event(struct swaybar *bar);
 void ipc_send_workspace_command(const char *workspace_name);
 
-#endif /* _SWAYBAR_IPC_H */
-
+#endif
-- 
cgit v1.2.3-70-g09d2


From 5c9ad035db1bebba3f1954dd1f4328c6421776d4 Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Wed, 28 Mar 2018 23:56:02 -0400
Subject: Wire up basic IPC support

---
 include/swaybar/bar.h    |   3 +
 include/swaybar/config.h |  17 ++--
 include/swaybar/ipc.h    |   5 +-
 swaybar/bar.c            |  11 +++
 swaybar/config.c         |  14 +---
 swaybar/ipc.c            | 199 +++++++++++++++++++++++++++++++++++++++++++++++
 swaybar/meson.build      |   1 +
 7 files changed, 225 insertions(+), 25 deletions(-)
 create mode 100644 swaybar/ipc.c

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/bar.h b/include/swaybar/bar.h
index 3ae8c0b3..df685f47 100644
--- a/include/swaybar/bar.h
+++ b/include/swaybar/bar.h
@@ -17,6 +17,9 @@ struct swaybar {
 	struct swaybar_config *config;
 	struct swaybar_output *focused_output;
 
+	int ipc_event_socketfd;
+	int ipc_socketfd;
+
 	struct wl_list outputs;
 };
 
diff --git a/include/swaybar/config.h b/include/swaybar/config.h
index 1bfe4843..4b3b5b34 100644
--- a/include/swaybar/config.h
+++ b/include/swaybar/config.h
@@ -2,21 +2,20 @@
 #define _SWAYBAR_CONFIG_H
 #include <stdbool.h>
 #include <stdint.h>
-#include "list.h"
+#include <wayland-client.h>
 #include "util.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_output {
+	struct wl_list link;
+	char *name;
+};
+
 struct swaybar_config {
 	char *status_command;
 	bool pango_markup;
@@ -28,8 +27,7 @@ struct swaybar_config {
 	bool binding_mode_indicator;
 	bool wrap_scroll;
 	bool workspace_buttons;
-	bool all_outputs;
-	list_t *outputs;
+	struct wl_list outputs;
 	int height;
 
 	struct {
@@ -51,5 +49,6 @@ struct swaybar_config {
 
 struct swaybar_config *init_config();
 void free_config(struct swaybar_config *config);
+uint32_t parse_position(const char *position);
 
 #endif
diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index 57a1b925..7f71a506 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -2,8 +2,7 @@
 #define _SWAYBAR_IPC_H
 #include "swaybar/bar.h"
 
-void ipc_bar_init(struct swaybar *bar, const char *bar_id);
-bool handle_ipc_event(struct swaybar *bar);
-void ipc_send_workspace_command(const char *workspace_name);
+void ipc_get_config(struct swaybar *bar, const char *bar_id);
+void handle_ipc_event(struct swaybar *bar);
 
 #endif
diff --git a/swaybar/bar.c b/swaybar/bar.c
index e1d594b4..433e2948 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -14,6 +14,8 @@
 #include "swaybar/config.h"
 #include "swaybar/event_loop.h"
 #include "swaybar/bar.h"
+#include "swaybar/ipc.h"
+#include "ipc-client.h"
 #include "list.h"
 #include "pango.h"
 #include "pool-buffer.h"
@@ -92,6 +94,10 @@ void bar_setup(struct swaybar *bar,
 	bar_init(bar);
 	init_event_loop();
 
+	bar->ipc_socketfd = ipc_open_socket(socket_path);
+	bar->ipc_event_socketfd = ipc_open_socket(socket_path);
+	ipc_get_config(bar, bar_id);
+
 	assert(bar->display = wl_display_connect(NULL));
 
 	struct wl_registry *registry = wl_display_get_registry(bar->display);
@@ -122,6 +128,11 @@ 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;
+	handle_ipc_event(bar);
+}
+
 void bar_run(struct swaybar *bar) {
 	add_event(wl_display_get_fd(bar->display), POLLIN, display_in, bar);
 	while (1) {
diff --git a/swaybar/config.c b/swaybar/config.c
index 0c2b57e0..83cf2309 100644
--- a/swaybar/config.c
+++ b/swaybar/config.c
@@ -22,17 +22,6 @@ uint32_t parse_position(const char *position) {
 	}
 }
 
-char *parse_font(const char *font) {
-	char *new_font = NULL;
-	if (strncmp("pango:", font, 6) == 0) {
-		font += 6;
-	}
-
-	new_font = strdup(font);
-
-	return new_font;
-}
-
 struct swaybar_config *init_config() {
 	struct swaybar_config *config = calloc(1, sizeof(struct swaybar_config));
 	config->status_command = NULL;
@@ -45,8 +34,7 @@ struct swaybar_config *init_config() {
 	config->binding_mode_indicator = true;
 	config->wrap_scroll = false;
 	config->workspace_buttons = true;
-	config->all_outputs = false;
-	config->outputs = create_list();
+	wl_list_init(&config->outputs);
 
 	/* height */
 	config->height = 0;
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
new file mode 100644
index 00000000..cef784d0
--- /dev/null
+++ b/swaybar/ipc.c
@@ -0,0 +1,199 @@
+#define _XOPEN_SOURCE 500
+#include <string.h>
+#include <strings.h>
+#include <json-c/json.h>
+#include "swaybar/config.h"
+#include "swaybar/ipc.h"
+#include "ipc-client.h"
+
+char *parse_font(const char *font) {
+	char *new_font = NULL;
+	if (strncmp("pango:", font, 6) == 0) {
+		font += 6;
+	}
+	new_font = strdup(font);
+	return new_font;
+}
+
+static void ipc_parse_colors(
+		struct swaybar_config *config, json_object *colors) {
+	json_object *background, *statusline, *separator;
+	json_object *focused_background, *focused_statusline, *focused_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_background", &focused_background);
+	json_object_object_get_ex(colors, "focused_statusline", &focused_statusline);
+	json_object_object_get_ex(colors, "focused_separator", &focused_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_background) {
+		config->colors.focused_background = parse_color(json_object_get_string(focused_background));
+	}
+	if (focused_statusline) {
+		config->colors.focused_statusline = parse_color(json_object_get_string(focused_statusline));
+	}
+	if (focused_separator) {
+		config->colors.focused_separator = parse_color(json_object_get_string(focused_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));
+	}
+}
+
+static void ipc_parse_config(
+		struct swaybar_config *config, const char *payload) {
+	json_object *bar_config = json_tokener_parse(payload);
+	json_object *markup, *mode, *hidden_bar, *position, *status_command;
+	json_object *font, *bar_height, *wrap_scroll, *workspace_buttons, *strip_workspace_numbers;
+	json_object *binding_mode_indicator, *verbose, *colors, *sep_symbol, *outputs;
+	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, "wrap_scroll", &wrap_scroll);
+	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);
+	json_object_object_get_ex(bar_config, "outputs", &outputs);
+	json_object_object_get_ex(bar_config, "pango_markup", &markup);
+	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 (wrap_scroll) {
+		config->wrap_scroll = json_object_get_boolean(wrap_scroll);
+	}
+	if (workspace_buttons) {
+		config->workspace_buttons = json_object_get_boolean(workspace_buttons);
+	}
+	if (bar_height) {
+		config->height = json_object_get_int(bar_height);
+	}
+	if (markup) {
+		config->pango_markup = json_object_get_boolean(markup);
+	}
+
+	struct config_output *output, *tmp;
+	wl_list_for_each_safe(output, tmp, &config->outputs, link) {
+		wl_list_remove(&output->link);
+		free(output->name);
+		free(output);
+	}
+	if (outputs) {
+		int length = json_object_array_length(outputs);
+		for (int i = 0; i < length; ++i) {
+			json_object *output = json_object_array_get_idx(outputs, i);
+			const char *name = json_object_get_string(output);
+			if (strcmp("*", name) == 0) {
+				// TODO: do we need to clear out the list here or something
+				break;
+			}
+			struct config_output *coutput = calloc(
+					1, sizeof(struct config_output));
+			coutput->name = strdup(name);
+			wl_list_insert(&config->outputs, &coutput->link);
+		}
+	}
+
+	if (colors) {
+		ipc_parse_colors(config, colors);
+	}
+
+	json_object_put(bar_config);
+}
+
+void ipc_get_config(struct swaybar *bar, const char *bar_id) {
+	uint32_t len = strlen(bar_id);
+	char *res = ipc_single_command(bar->ipc_socketfd,
+			IPC_GET_BAR_CONFIG, bar_id, &len);
+	ipc_parse_config(bar->config, res);
+	free(res);
+}
+
+void handle_ipc_event(struct swaybar *bar) {
+	struct ipc_response *resp = ipc_recv_response(bar->ipc_event_socketfd);
+	free_ipc_response(resp);
+}
diff --git a/swaybar/meson.build b/swaybar/meson.build
index fd87e51d..6dc7c564 100644
--- a/swaybar/meson.build
+++ b/swaybar/meson.build
@@ -4,6 +4,7 @@ executable(
 		'bar.c',
 		'config.c',
 		'event_loop.c',
+		'ipc.c',
 		'main.c',
 		'render.c',
 	],
-- 
cgit v1.2.3-70-g09d2


From 3399ad9840f0d3d42b377f4404115d887f65e18a Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Thu, 29 Mar 2018 00:21:05 -0400
Subject: Round up workspaces on each output

---
 include/swaybar/bar.h | 16 +++++++++++--
 include/swaybar/ipc.h |  3 ++-
 swaybar/bar.c         |  9 ++++++--
 swaybar/ipc.c         | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 85 insertions(+), 6 deletions(-)

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/bar.h b/include/swaybar/bar.h
index 6e1ab66d..c89aa61c 100644
--- a/include/swaybar/bar.h
+++ b/include/swaybar/bar.h
@@ -30,6 +30,8 @@ struct swaybar_output {
 	struct wl_surface *surface;
 	struct zwlr_layer_surface_v1 *layer_surface;
 
+	struct wl_list workspaces;
+
 	char *name;
 	size_t index;
 	bool focused;
@@ -39,9 +41,19 @@ struct swaybar_output {
 	struct pool_buffer *current_buffer;
 };
 
+struct swaybar_workspace {
+	struct wl_list link;
+	int num;
+	char *name;
+	bool focused;
+	bool visible;
+	bool urgent;
+};
+
+// TODO: Rename stuff to match wlroots conventions (init/create/etc)
 void bar_setup(struct swaybar *bar,
-		const char *socket_path,
-		const char *bar_id);
+	const char *socket_path,
+	const char *bar_id);
 void bar_run(struct swaybar *bar);
 void bar_teardown(struct swaybar *bar);
 
diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index 7f71a506..f3881bd0 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -2,7 +2,8 @@
 #define _SWAYBAR_IPC_H
 #include "swaybar/bar.h"
 
-void ipc_get_config(struct swaybar *bar, const char *bar_id);
+void ipc_initialize(struct swaybar *bar, const char *bar_id);
 void handle_ipc_event(struct swaybar *bar);
+void ipc_get_workspaces(struct swaybar *bar);
 
 #endif
diff --git a/swaybar/bar.c b/swaybar/bar.c
index a6e3b780..68dea408 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -72,6 +72,7 @@ static void handle_global(void *data, struct wl_registry *registry,
 		output->output = wl_registry_bind(registry, name,
 				&wl_output_interface, 1);
 		output->index = index++;
+		wl_list_init(&output->workspaces);
 		wl_list_insert(&bar->outputs, &output->link);
 	} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
 		bar->layer_shell = wl_registry_bind(
@@ -96,7 +97,7 @@ void bar_setup(struct swaybar *bar,
 
 	bar->ipc_socketfd = ipc_open_socket(socket_path);
 	bar->ipc_event_socketfd = ipc_open_socket(socket_path);
-	ipc_get_config(bar, bar_id);
+	ipc_initialize(bar, bar_id);
 
 	assert(bar->display = wl_display_connect(NULL));
 
@@ -113,6 +114,7 @@ void bar_setup(struct swaybar *bar,
 			if (coutput->index != output->index) {
 				continue;
 			}
+			output->name = strdup(coutput->name);
 			assert(output->surface = wl_compositor_create_surface(
 					bar->compositor));
 			output->layer_surface = zwlr_layer_shell_v1_get_layer_surface(
@@ -123,10 +125,13 @@ void bar_setup(struct swaybar *bar,
 					&layer_surface_listener, output);
 			zwlr_layer_surface_v1_set_anchor(output->layer_surface,
 					bar->config->position);
-			render_frame(bar, output);
 			break;
 		}
 	}
+	ipc_get_workspaces(bar);
+	wl_list_for_each(output, &bar->outputs, link) {
+		render_frame(bar, output);
+	}
 }
 
 static void display_in(int fd, short mask, void *_bar) {
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index d3ee170c..6b832070 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -187,6 +187,65 @@ static void ipc_parse_config(
 	json_object_put(bar_config);
 }
 
+static void free_workspaces(struct wl_list *list) {
+	struct swaybar_workspace *ws, *tmp;
+	wl_list_for_each_safe(ws, tmp, list, link) {
+		wl_list_remove(&ws->link);
+		free(ws->name);
+		free(ws);
+	}
+}
+
+void ipc_get_workspaces(struct swaybar *bar) {
+	struct swaybar_output *output;
+	wl_list_for_each(output, &bar->outputs, link) {
+		free_workspaces(&output->workspaces);
+	}
+	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;
+	}
+	size_t length = json_object_array_length(results);
+	json_object *ws_json;
+	json_object *num, *name, *visible, *focused, *out, *urgent;
+	for (size_t 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);
+
+		wl_list_for_each(output, &bar->outputs, link) {
+			const char *ws_output = json_object_get_string(out);
+			if (strcmp(ws_output, output->name) == 0) {
+				struct swaybar_workspace *ws =
+					calloc(1, sizeof(struct swaybar_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);
+				if (ws->focused) {
+					if (bar->focused_output) {
+						bar->focused_output->focused = false;
+					}
+					bar->focused_output = output;
+					output->focused = true;
+				}
+				ws->urgent = json_object_get_boolean(urgent);
+				wl_list_insert(&output->workspaces, &ws->link);
+			}
+		}
+	}
+	free(res);
+}
+
 static void ipc_get_outputs(struct swaybar *bar) {
 	uint32_t len = 0;
 	char *res = ipc_single_command(bar->ipc_socketfd,
@@ -218,16 +277,18 @@ static void ipc_get_outputs(struct swaybar *bar) {
 			}
 		}
 	}
+	json_object_put(outputs);
 	free(res);
 }
 
-void ipc_get_config(struct swaybar *bar, const char *bar_id) {
+void ipc_initialize(struct swaybar *bar, const char *bar_id) {
 	uint32_t len = strlen(bar_id);
 	char *res = ipc_single_command(bar->ipc_socketfd,
 			IPC_GET_BAR_CONFIG, bar_id, &len);
 	ipc_parse_config(bar->config, res);
 	free(res);
 	ipc_get_outputs(bar);
+	// TODO: subscribe to stuff
 }
 
 void handle_ipc_event(struct swaybar *bar) {
-- 
cgit v1.2.3-70-g09d2


From 86ba0fc15d7615b09f0279616d538af5c23bc551 Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Thu, 29 Mar 2018 10:38:17 -0400
Subject: Re-render bar on IPC updates

---
 include/swaybar/ipc.h |  3 ++-
 swaybar/bar.c         |  8 +++++++-
 swaybar/ipc.c         | 46 ++++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 53 insertions(+), 4 deletions(-)

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index f3881bd0..278baef0 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -1,9 +1,10 @@
 #ifndef _SWAYBAR_IPC_H
 #define _SWAYBAR_IPC_H
+#include <stdbool.h>
 #include "swaybar/bar.h"
 
 void ipc_initialize(struct swaybar *bar, const char *bar_id);
-void handle_ipc_event(struct swaybar *bar);
+bool handle_ipc_event(struct swaybar *bar);
 void ipc_get_workspaces(struct swaybar *bar);
 
 #endif
diff --git a/swaybar/bar.c b/swaybar/bar.c
index 68dea408..90fd5ad4 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -143,11 +143,17 @@ 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;
-	handle_ipc_event(bar);
+	if (handle_ipc_event(bar)) {
+		struct swaybar_output *output;
+		wl_list_for_each(output, &bar->outputs, link) {
+			render_frame(bar, output);
+		}
+	}
 }
 
 void bar_run(struct swaybar *bar) {
 	add_event(wl_display_get_fd(bar->display), POLLIN, display_in, bar);
+	add_event(bar->ipc_event_socketfd, POLLIN, ipc_in, bar);
 	while (1) {
 		event_loop_poll();
 	}
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index 6b832070..75f17953 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -3,6 +3,7 @@
 #include <string.h>
 #include <strings.h>
 #include <json-c/json.h>
+#include <wlr/util/log.h>
 #include "swaybar/config.h"
 #include "swaybar/ipc.h"
 #include "ipc-client.h"
@@ -288,10 +289,51 @@ void ipc_initialize(struct swaybar *bar, const char *bar_id) {
 	ipc_parse_config(bar->config, res);
 	free(res);
 	ipc_get_outputs(bar);
-	// TODO: subscribe to stuff
+
+	const char *subscribe = "[ \"workspace\", \"mode\" ]";
+	len = strlen(subscribe);
+	free(ipc_single_command(bar->ipc_event_socketfd,
+			IPC_SUBSCRIBE, subscribe, &len));
 }
 
-void handle_ipc_event(struct swaybar *bar) {
+bool handle_ipc_event(struct swaybar *bar) {
 	struct ipc_response *resp = ipc_recv_response(bar->ipc_event_socketfd);
+	if (!resp) {
+		return false;
+	}
+	switch (resp->type) {
+	case IPC_EVENT_WORKSPACE:
+		ipc_get_workspaces(bar);
+		break;
+	case IPC_EVENT_MODE: {
+		json_object *result = json_tokener_parse(resp->payload);
+		if (!result) {
+			free_ipc_response(resp);
+			wlr_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 {
+			wlr_log(L_ERROR, "failed to parse response");
+			json_object_put(result);
+			free_ipc_response(resp);
+			return false;
+		}
+		json_object_put(result);
+		break;
+	}
+	default:
+		free_ipc_response(resp);
+		return false;
+	}
 	free_ipc_response(resp);
+	return true;
 }
-- 
cgit v1.2.3-70-g09d2


From ae14dfc7ae70f16a31a10f4ff2395d4ac432308d Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Fri, 30 Mar 2018 22:02:55 -0400
Subject: Implement scroll wheel workspace switching

---
 include/swaybar/ipc.h |  1 +
 swaybar/bar.c         | 44 ++++++++++++++++++++++++++++++++++++++++----
 swaybar/ipc.c         |  8 ++++++++
 3 files changed, 49 insertions(+), 4 deletions(-)

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index 278baef0..6ea7c4d6 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -6,5 +6,6 @@
 void ipc_initialize(struct swaybar *bar, const char *bar_id);
 bool handle_ipc_event(struct swaybar *bar);
 void ipc_get_workspaces(struct swaybar *bar);
+void ipc_send_workspace_command(struct swaybar *bar, const char *ws);
 
 #endif
diff --git a/swaybar/bar.c b/swaybar/bar.c
index e7b8b2ca..5679a892 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -24,6 +24,7 @@
 #include "swaybar/ipc.h"
 #include "ipc-client.h"
 #include "list.h"
+#include "log.h"
 #include "pango.h"
 #include "pool-buffer.h"
 #include "wlr-layer-shell-unstable-v1-client-protocol.h"
@@ -67,6 +68,13 @@ static void wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
 		wl_fixed_t surface_x, wl_fixed_t surface_y) {
 	struct swaybar *bar = data;
 	struct swaybar_pointer *pointer = &bar->pointer;
+	struct swaybar_output *output;
+	wl_list_for_each(output, &bar->outputs, link) {
+		if (output->surface == surface) {
+			pointer->current = output;
+			break;
+		}
+	}
 	wl_surface_attach(pointer->cursor_surface,
 			wl_cursor_image_get_buffer(pointer->cursor_image), 0, 0);
 	wl_pointer_set_cursor(wl_pointer, serial, pointer->cursor_surface,
@@ -77,12 +85,12 @@ static void wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
 
 static void wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
 		uint32_t serial, struct wl_surface *surface) {
-	// Who cares
+	struct swaybar *bar = data;
+	bar->pointer.current = NULL;
 }
 
 static void wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
 		uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
-	wlr_log(L_DEBUG, "motion");
 	// TODO
 }
 
@@ -94,8 +102,36 @@ static void wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
 
 static void wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
 		uint32_t time, uint32_t axis, wl_fixed_t value) {
-	wlr_log(L_DEBUG, "axis");
-	// TODO
+	struct swaybar *bar = data;
+	struct swaybar_output *output = bar->pointer.current;
+	if (!output) {
+		return;
+	}
+	double amt = wl_fixed_to_double(value);
+	if (!bar->config->wrap_scroll) {
+		int i = 0;
+		struct swaybar_workspace *ws = NULL;
+		wl_list_for_each(ws, &output->workspaces, link) {
+			if (ws->focused) {
+				break;
+			}
+			++i;
+		}
+		int len = wl_list_length(&output->workspaces);
+		if (!sway_assert(i != len, "axis with null workspace")) {
+			return;
+		}
+		if (i == 0 && amt > 0) {
+			return; // Do not wrap
+		}
+		if (i == len - 1 && amt < 0) {
+			return; // Do not wrap
+		}
+	}
+
+	const char *workspace_name =
+		amt < 0 ?  "prev_on_output" : "next_on_output";
+	ipc_send_workspace_command(bar, workspace_name);
 }
 
 static void wl_pointer_frame(void *data, struct wl_pointer *wl_pointer) {
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index 326f25cc..64583df0 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -8,6 +8,14 @@
 #include "swaybar/ipc.h"
 #include "ipc-client.h"
 
+void ipc_send_workspace_command(struct swaybar *bar, const char *ws) {
+	const char *fmt = "workspace \"%s\"";
+	uint32_t size = snprintf(NULL, 0, fmt, ws);
+	char command[size];
+	snprintf(command, size, fmt, ws);
+	ipc_single_command(bar->ipc_socketfd, IPC_COMMAND, command, &size);
+}
+
 char *parse_font(const char *font) {
 	char *new_font = NULL;
 	if (strncmp("pango:", font, 6) == 0) {
-- 
cgit v1.2.3-70-g09d2


From 333dbcbe72b6af95573e374b66ad6ab63f274299 Mon Sep 17 00:00:00 2001
From: Drew DeVault <sir@cmpwn.com>
Date: Sat, 31 Mar 2018 14:39:18 -0400
Subject: Render i3bar blocks

---
 include/swaybar/ipc.h         |   2 +-
 include/swaybar/status_line.h |   6 +-
 swaybar/bar.c                 |   4 +-
 swaybar/i3bar.c               | 120 ++++++++++++++++++++++--
 swaybar/ipc.c                 |   2 +-
 swaybar/render.c              | 209 +++++++++++++++++++++++++++++++++++++++---
 swaybar/status_line.c         |   5 +-
 7 files changed, 314 insertions(+), 34 deletions(-)

(limited to 'include/swaybar/ipc.h')

diff --git a/include/swaybar/ipc.h b/include/swaybar/ipc.h
index 6ea7c4d6..a1696bcf 100644
--- a/include/swaybar/ipc.h
+++ b/include/swaybar/ipc.h
@@ -4,7 +4,7 @@
 #include "swaybar/bar.h"
 
 void ipc_initialize(struct swaybar *bar, const char *bar_id);
-bool handle_ipc_event(struct swaybar *bar);
+bool handle_ipc_readable(struct swaybar *bar);
 void ipc_get_workspaces(struct swaybar *bar);
 void ipc_send_workspace_command(struct swaybar *bar, const char *ws);
 
diff --git a/include/swaybar/status_line.h b/include/swaybar/status_line.h
index 3b93e28f..038985a3 100644
--- a/include/swaybar/status_line.h
+++ b/include/swaybar/status_line.h
@@ -38,7 +38,7 @@ struct i3bar_block {
 	struct wl_list link;
 	char *full_text, *short_text, *align;
 	bool urgent;
-	uint32_t color;
+	uint32_t *color;
 	int min_width;
 	char *name, *instance;
 	bool separator;
@@ -68,8 +68,8 @@ struct status_line {
 
 struct status_line *status_line_init(char *cmd);
 void status_line_free(struct status_line *status);
-bool handle_status_readable(struct status_line *status);
-int i3bar_readable(struct status_line *status);
+bool status_handle_readable(struct status_line *status);
+bool i3bar_handle_readable(struct status_line *status);
 void status_error(struct status_line *status, const char *text);
 
 #endif
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);
-- 
cgit v1.2.3-70-g09d2