Merge branch 'wlroots'

15 files changed, 1333 insertions, 3351 deletions

diff --git a/swaybar/CMakeLists.txt b/swaybar/CMakeLists.txt
deleted file mode 100644
index 48ededdd..00000000
--- a/swaybar/CMakeLists.txt
+++ /dev/null
@@ -1,51 +0,0 @@
-include_directories(
-        ${PROTOCOLS_INCLUDE_DIRS}
-        ${WAYLAND_INCLUDE_DIR}
-        ${CAIRO_INCLUDE_DIRS}
-        ${PANGO_INCLUDE_DIRS}
-        ${JSONC_INCLUDE_DIRS}
-        ${XKBCOMMON_INCLUDE_DIRS}
-        ${DBUS_INCLUDE_DIRS}
-)
-if (ENABLE_TRAY)
-        file(GLOB tray
-                tray/*.c
-        )
-endif()
-
-add_executable(swaybar
-        main.c
-        config.c
-        render.c
-        bar.c
-        status_line.c
-        ipc.c
-        event_loop.c
-        ${tray}
-)
-
-target_link_libraries(swaybar
-        sway-common
-        sway-wayland
-        ${WAYLAND_CLIENT_LIBRARIES}
-        ${WAYLAND_CURSOR_LIBRARIES}
-        ${CAIRO_LIBRARIES}
-        ${PANGO_LIBRARIES}
-        ${JSONC_LIBRARIES}
-        ${DBUS_LIBRARIES}
-)
-
-if (WITH_GDK_PIXBUF)
-        include_directories(
-                ${GDK_PIXBUF_INCLUDE_DIRS}
-        )
-endif()
-
-target_link_libraries(swaybar rt)
-
-install(
-        TARGETS swaybar
-        RUNTIME
-        DESTINATION bin
-        COMPONENT runtime
-)
diff --git a/swaybar/bar.c b/swaybar/bar.c
index f12923a8..d51c4ec7 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -1,390 +1,456 @@
 #define _XOPEN_SOURCE 500
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <string.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <sys/wait.h>
-#include <signal.h>
-#include <poll.h>
+#include <unistd.h>
+#include <wayland-client.h>
+#include <wayland-cursor.h>
+#include <wlr/util/log.h>
 #ifdef __FreeBSD__
 #include <dev/evdev/input-event-codes.h>
 #else
 #include <linux/input-event-codes.h>
 #endif
-#ifdef ENABLE_TRAY
-#include <dbus/dbus.h>
-#include "swaybar/tray/sni_watcher.h"
-#include "swaybar/tray/tray.h"
-#include "swaybar/tray/sni.h"
-#endif
-#include "swaybar/ipc.h"
 #include "swaybar/render.h"
 #include "swaybar/config.h"
-#include "swaybar/status_line.h"
 #include "swaybar/event_loop.h"
+#include "swaybar/status_line.h"
 #include "swaybar/bar.h"
+#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"
 
-static void bar_init(struct bar *bar) {
+static void bar_init(struct swaybar *bar) {
         bar->config = init_config();
-        bar->status = init_status_line();
-        bar->outputs = create_list();
+        wl_list_init(&bar->outputs);
 }
 
-static void spawn_status_cmd_proc(struct bar *bar) {
-        if (bar->config->status_command) {
-                int pipe_read_fd[2];
-                int pipe_write_fd[2];
-
-                if (pipe(pipe_read_fd) != 0) {
-                        sway_log(L_ERROR, "Unable to create pipes for status_command fork");
-                        return;
-                }
-                if (pipe(pipe_write_fd) != 0) {
-                        sway_log(L_ERROR, "Unable to create pipe for status_command fork (write)");
-                        close(pipe_read_fd[0]);
-                        close(pipe_read_fd[1]);
-                        return;
-                }
-
-                bar->status_command_pid = fork();
-                if (bar->status_command_pid == 0) {
-                        close(pipe_read_fd[0]);
-                        dup2(pipe_read_fd[1], STDOUT_FILENO);
-                        close(pipe_read_fd[1]);
-                        
-                        dup2(pipe_write_fd[0], STDIN_FILENO);
-                        close(pipe_write_fd[0]);
-                        close(pipe_write_fd[1]);
-                        
-                        char *const cmd[] = {
-                                "sh",
-                                "-c",
-                                bar->config->status_command,
-                                NULL,
-                        };
-                        execvp(cmd[0], cmd);
-                        return;
+static void swaybar_output_free(struct swaybar_output *output) {
+        if (!output) {
+                return;
+        }
+        wlr_log(L_DEBUG, "Removing output %s", output->name);
+        zwlr_layer_surface_v1_destroy(output->layer_surface);
+        wl_surface_destroy(output->surface);
+        wl_output_destroy(output->output);
+        destroy_buffer(&output->buffers[0]);
+        destroy_buffer(&output->buffers[1]);
+        struct swaybar_workspace *ws, *ws_tmp;
+        wl_list_for_each_safe(ws, ws_tmp, &output->workspaces, link) {
+                wl_list_remove(&ws->link);
+                free(ws->name);
+                free(ws);
+        }
+        struct swaybar_hotspot *hotspot, *hotspot_tmp;
+        wl_list_for_each_safe(hotspot, hotspot_tmp, &output->hotspots, link) {
+                if (hotspot->destroy) {
+                        hotspot->destroy(hotspot->data);
                 }
-
-                close(pipe_read_fd[1]);
-                bar->status_read_fd = pipe_read_fd[0];
-                fcntl(bar->status_read_fd, F_SETFL, O_NONBLOCK);
-                
-                close(pipe_write_fd[0]);
-                bar->status_write_fd = pipe_write_fd[1];
-                fcntl(bar->status_write_fd, F_SETFL, O_NONBLOCK);
+                free(hotspot);
         }
+        wl_list_remove(&output->link);
+        free(output->name);
+        free(output);
 }
 
-struct output *new_output(const char *name) {
-        struct output *output = malloc(sizeof(struct output));
-        output->name = strdup(name);
-        output->window = NULL;
-        output->registry = NULL;
-        output->workspaces = create_list();
-#ifdef ENABLE_TRAY
-        output->items = create_list();
-#endif
-        return output;
+static void layer_surface_configure(void *data,
+                struct zwlr_layer_surface_v1 *surface,
+                uint32_t serial, uint32_t width, uint32_t height) {
+        struct swaybar_output *output = data;
+        output->width = width;
+        output->height = height;
+        zwlr_layer_surface_v1_ack_configure(surface, serial);
+        render_frame(output->bar, output);
 }
 
-static void mouse_button_notify(struct window *window, int x, int y,
-                uint32_t button, uint32_t state_w) {
-        sway_log(L_DEBUG, "Mouse button %d clicked at %d %d %d", button, x, y, state_w);
-        if (!state_w) {
-                return;
-        }
+static void layer_surface_closed(void *_output,
+                struct zwlr_layer_surface_v1 *surface) {
+        struct swaybar_output *output = _output;
+        swaybar_output_free(output);
+}
 
-        struct output *clicked_output = NULL;
-        for (int i = 0; i < swaybar.outputs->length; i++) {
-                struct output *output = swaybar.outputs->items[i];
-                if (window == output->window) {
-                        clicked_output = output;
+struct zwlr_layer_surface_v1_listener layer_surface_listener = {
+        .configure = layer_surface_configure,
+        .closed = layer_surface_closed,
+};
+
+static void wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
+                uint32_t serial, struct wl_surface *surface,
+                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;
                 }
         }
-
-        if (!sway_assert(clicked_output != NULL, "Got pointer event for non-existing output")) {
-                return;
-        }
-
-        double button_x = 0.5;
-        for (int i = 0; i < clicked_output->workspaces->length; i++) {
-                struct workspace *workspace = clicked_output->workspaces->items[i];
-                int button_width, button_height;
-
-                workspace_button_size(window, workspace->name, &button_width, &button_height);
-
-                button_x += button_width;
-                if (x <= button_x) {
-                        ipc_send_workspace_command(workspace->name);
-                        break;
+        int max_scale = 1;
+        struct swaybar_output *_output;
+        wl_list_for_each(_output, &bar->outputs, link) {
+                if (_output->scale > max_scale) {
+                        max_scale = _output->scale;
                 }
         }
+        wl_surface_set_buffer_scale(pointer->cursor_surface, max_scale);
+        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,
+                        pointer->cursor_image->hotspot_x / max_scale,
+                        pointer->cursor_image->hotspot_y / max_scale);
+        wl_surface_commit(pointer->cursor_surface);
+}
 
-        switch (button) {
-        case BTN_LEFT:
-                status_line_mouse_event(&swaybar, x, y, 1);
-                break;
-        case BTN_MIDDLE:
-                status_line_mouse_event(&swaybar, x, y, 2);
-                break;
-        case BTN_RIGHT:
-                status_line_mouse_event(&swaybar, x, y, 3);
-                break;
-        }
-
-#ifdef ENABLE_TRAY
-        tray_mouse_event(clicked_output, x, y, button, state_w);
-#endif
+static void wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
+                uint32_t serial, struct wl_surface *surface) {
+        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) {
+        struct swaybar *bar = data;
+        bar->pointer.x = wl_fixed_to_int(surface_x);
+        bar->pointer.y = wl_fixed_to_int(surface_y);
 }
 
-static void mouse_scroll_notify(struct window *window, enum scroll_direction direction) {
-        sway_log(L_DEBUG, "Mouse wheel scrolled %s", direction == SCROLL_UP ? "up" : "down");
-
-        // If there are status blocks and click_events are enabled
-        // check if the position is within the status area and if so
-        // tell the status line to output the event and skip workspace
-        // switching below.
-        int num_blocks = swaybar.status->block_line->length;
-        if (swaybar.status->click_events && num_blocks > 0) {
-                struct status_block *first_block = swaybar.status->block_line->items[0];
-                int x = window->pointer_input.last_x;
-                int y = window->pointer_input.last_y;
-                if (x > first_block->x) {
-                        if (direction == SCROLL_UP) {
-                                status_line_mouse_event(&swaybar, x, y, 4);
-                        } else {
-                                status_line_mouse_event(&swaybar, x, y, 5);
-                        }
-                        return;
+static void wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
+                uint32_t serial, uint32_t time, uint32_t button, uint32_t state) {
+        struct swaybar *bar = data;
+        struct swaybar_pointer *pointer = &bar->pointer;
+        struct swaybar_output *output = pointer->current;
+        if (!sway_assert(output, "button with no active output")) {
+                return;
+        }
+        if (state != WL_POINTER_BUTTON_STATE_PRESSED) {
+                return;
+        }
+        struct swaybar_hotspot *hotspot;
+        wl_list_for_each(hotspot, &output->hotspots, link) {
+                double x = pointer->x * output->scale;
+                double y = pointer->y * output->scale;
+                if (x >= hotspot->x
+                                && y >= hotspot->y
+                                && x < hotspot->x + hotspot->width
+                                && y < hotspot->y + hotspot->height) {
+                        hotspot->callback(output, pointer->x, pointer->y,
+                                        button, hotspot->data);
                 }
         }
+}
 
-        if (!swaybar.config->wrap_scroll) {
-                // Find output this window lives on
-                int i;
-                struct output *output = NULL;
-                for (i = 0; i < swaybar.outputs->length; ++i) {
-                        output = swaybar.outputs->items[i];
-                        if (output->window == window) {
-                                break;
-                        }
-                }
-                if (!sway_assert(i != swaybar.outputs->length, "Unknown window in scroll event")) {
-                        return;
-                }
-                int focused = -1;
-                for (i = 0; i < output->workspaces->length; ++i) {
-                        struct workspace *ws = output->workspaces->items[i];
+static void wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
+                uint32_t time, uint32_t axis, wl_fixed_t value) {
+        struct swaybar *bar = data;
+        struct swaybar_output *output = bar->pointer.current;
+        if (!sway_assert(output, "axis with no active 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) {
-                                focused = i;
                                 break;
                         }
+                        ++i;
                 }
-                if (!sway_assert(focused != -1, "Scroll wheel event received on inactive output")) {
+                int len = wl_list_length(&output->workspaces);
+                if (!sway_assert(i != len, "axis with null workspace")) {
                         return;
                 }
-                if ((focused == 0 && direction == SCROLL_UP) ||
-                                (focused == output->workspaces->length - 1 && direction == SCROLL_DOWN)) {
-                        // Do not wrap
-                        return;
+                if (i == 0 && amt > 0) {
+                        return; // Do not wrap
+                }
+                if (i == len - 1 && amt < 0) {
+                        return; // Do not wrap
                 }
         }
 
-        const char *workspace_name = direction == SCROLL_UP ? "prev_on_output" : "next_on_output";
-        ipc_send_workspace_command(workspace_name);
+        const char *workspace_name =
+                amt < 0 ?  "prev_on_output" : "next_on_output";
+        ipc_send_workspace_command(bar, workspace_name);
 }
 
-void bar_setup(struct bar *bar, const char *socket_path, const char *bar_id) {
-        /* initialize bar with default values */
-        bar_init(bar);
-
-        /* Initialize event loop lists */
-        init_event_loop();
-
-        /* 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, bar_id);
-
-        int i;
-        for (i = 0; i < bar->outputs->length; ++i) {
-                struct output *bar_output = bar->outputs->items[i];
-
-                bar_output->registry = registry_poll();
-
-                if (!bar_output->registry->desktop_shell) {
-                        sway_abort("swaybar requires the compositor to support the desktop-shell extension.");
-                }
-
-                struct output_state *output = bar_output->registry->outputs->items[bar_output->idx];
-
-                bar_output->window = window_setup(bar_output->registry,
-                                output->width / output->scale, 30, output->scale, 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);
+static void wl_pointer_frame(void *data, struct wl_pointer *wl_pointer) {
+        // Who cares
+}
 
-                window_make_shell(bar_output->window);
+static void wl_pointer_axis_source(void *data, struct wl_pointer *wl_pointer,
+                uint32_t axis_source) {
+        // Who cares
+}
 
-                /* set font */
-                bar_output->window->font = bar->config->font;
+static void wl_pointer_axis_stop(void *data, struct wl_pointer *wl_pointer,
+                uint32_t time, uint32_t axis) {
+        // Who cares
+}
 
-                /* set mouse event callbacks */
-                bar_output->window->pointer_input.notify_button = mouse_button_notify;
-                bar_output->window->pointer_input.notify_scroll = mouse_scroll_notify;
+static void wl_pointer_axis_discrete(void *data, struct wl_pointer *wl_pointer,
+                uint32_t axis, int32_t discrete) {
+        // Who cares
+}
 
-                /* set window height */
-                set_window_height(bar_output->window, bar->config->height);
+struct wl_pointer_listener pointer_listener = {
+        .enter = wl_pointer_enter,
+        .leave = wl_pointer_leave,
+        .motion = wl_pointer_motion,
+        .button = wl_pointer_button,
+        .axis = wl_pointer_axis,
+        .frame = wl_pointer_frame,
+        .axis_source = wl_pointer_axis_source,
+        .axis_stop = wl_pointer_axis_stop,
+        .axis_discrete = wl_pointer_axis_discrete,
+};
+
+static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
+                enum wl_seat_capability caps) {
+        struct swaybar *bar = data;
+        if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
+                bar->pointer.pointer = wl_seat_get_pointer(wl_seat);
+                wl_pointer_add_listener(bar->pointer.pointer, &pointer_listener, bar);
         }
-        /* spawn status command */
-        spawn_status_cmd_proc(bar);
+}
 
-#ifdef ENABLE_TRAY
-        init_tray(bar);
-#endif
+static void seat_handle_name(void *data, struct wl_seat *wl_seat,
+                const char *name) {
+        // Who cares
 }
 
-bool dirty = true;
+const struct wl_seat_listener seat_listener = {
+        .capabilities = seat_handle_capabilities,
+        .name = seat_handle_name,
+};
 
-static void respond_ipc(int fd, short mask, void *_bar) {
-        struct bar *bar = (struct bar *)_bar;
-        sway_log(L_DEBUG, "Got IPC event.");
-        dirty = handle_ipc_event(bar);
+static void output_geometry(void *data, struct wl_output *output, int32_t x,
+                int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel,
+                const char *make, const char *model, int32_t transform) {
+        // Who cares
 }
 
-static void respond_command(int fd, short mask, void *_bar) {
-        struct bar *bar = (struct bar *)_bar;
-        dirty = handle_status_line(bar);
+static void output_mode(void *data, struct wl_output *output, uint32_t flags,
+                int32_t width, int32_t height, int32_t refresh) {
+        // Who cares
 }
 
-static void respond_output(int fd, short mask, void *_output) {
-        struct output *output = (struct output *)_output;
-        if (wl_display_dispatch(output->registry->display) == -1) {
-                sway_log(L_ERROR, "failed to dispatch wl: %d", errno);
+static void output_done(void *data, struct wl_output *output) {
+        // Who cares
+}
+
+static void output_scale(void *data, struct wl_output *wl_output,
+                int32_t factor) {
+        struct swaybar_output *output = data;
+        output->scale = factor;
+        if (output->surface) {
+                render_frame(output->bar, output);
         }
 }
 
-void bar_run(struct bar *bar) {
-        add_event(bar->ipc_event_socketfd, POLLIN, respond_ipc, bar);
-        add_event(bar->status_read_fd, POLLIN, respond_command, bar);
+struct wl_output_listener output_listener = {
+        .geometry = output_geometry,
+        .mode = output_mode,
+        .done = output_done,
+        .scale = output_scale,
+};
 
-        int i;
-        for (i = 0; i < bar->outputs->length; ++i) {
-                struct output *output = bar->outputs->items[i];
-                add_event(wl_display_get_fd(output->registry->display),
-                                POLLIN, respond_output, output);
+static bool bar_uses_output(struct swaybar *bar, size_t output_index) {
+        if (bar->config->all_outputs) {
+                return true;
         }
-
-        while (1) {
-                if (dirty) {
-                        int i;
-                        for (i = 0; i < bar->outputs->length; ++i) {
-                                struct output *output = bar->outputs->items[i];
-                                if (window_prerender(output->window) && output->window->cairo) {
-                                        render(output, bar->config, bar->status);
-                                        window_render(output->window);
-                                        wl_display_flush(output->registry->display);
-                                }
-                        }
+        struct config_output *coutput;
+        wl_list_for_each(coutput, &bar->config->outputs, link) {
+                if (coutput->index == output_index) {
+                        return true;
                 }
+        }
+        return false;
+}
 
-                dirty = false;
-
-                event_loop_poll();
-#ifdef ENABLE_TRAY
-                dispatch_dbus();
-#endif
+static void handle_global(void *data, struct wl_registry *registry,
+                uint32_t name, const char *interface, uint32_t version) {
+        struct swaybar *bar = data;
+        if (strcmp(interface, wl_compositor_interface.name) == 0) {
+                bar->compositor = wl_registry_bind(registry, name,
+                                &wl_compositor_interface, 3);
+        } else if (strcmp(interface, wl_seat_interface.name) == 0) {
+                bar->seat = wl_registry_bind(registry, name,
+                                &wl_seat_interface, 1);
+                wl_seat_add_listener(bar->seat, &seat_listener, bar);
+        } else if (strcmp(interface, wl_shm_interface.name) == 0) {
+                bar->shm = wl_registry_bind(registry, name,
+                                &wl_shm_interface, 1);
+        } else if (strcmp(interface, wl_output_interface.name) == 0) {
+                static size_t output_index = 0;
+                if (bar_uses_output(bar, output_index)) {
+                        struct swaybar_output *output =
+                                calloc(1, sizeof(struct swaybar_output));
+                        output->bar = bar;
+                        output->output = wl_registry_bind(registry, name,
+                                        &wl_output_interface, 3);
+                        wl_output_add_listener(output->output, &output_listener, output);
+                        output->scale = 1;
+                        output->index = output_index;
+                        output->wl_name = name;
+                        wl_list_init(&output->workspaces);
+                        wl_list_init(&output->hotspots);
+                        wl_list_insert(&bar->outputs, &output->link);
+                }
+                ++output_index;
+        } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
+                bar->layer_shell = wl_registry_bind(
+                                registry, name, &zwlr_layer_shell_v1_interface, 1);
         }
 }
 
-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);
+static void handle_global_remove(void *data, struct wl_registry *registry,
+                uint32_t name) {
+        struct swaybar *bar = data;
+        struct swaybar_output *output, *tmp;
+        wl_list_for_each_safe(output, tmp, &bar->outputs, link) {
+                if (output->wl_name == name) {
+                        swaybar_output_free(output);
+                        break;
+                }
         }
-        list_free(workspaces);
 }
 
-static void free_output(struct output *output) {
-        window_teardown(output->window);
-        if (output->registry) {
-                registry_teardown(output->registry);
+static const struct wl_registry_listener registry_listener = {
+        .global = handle_global,
+        .global_remove = handle_global_remove,
+};
+
+static void render_all_frames(struct swaybar *bar) {
+        struct swaybar_output *output;
+        wl_list_for_each(output, &bar->outputs, link) {
+                render_frame(bar, output);
         }
+}
 
-        free(output->name);
+void bar_setup(struct swaybar *bar,
+                const char *socket_path, const char *bar_id) {
+        bar_init(bar);
+        init_event_loop();
 
-        if (output->workspaces) {
-                free_workspaces(output->workspaces);
+        bar->ipc_socketfd = ipc_open_socket(socket_path);
+        bar->ipc_event_socketfd = ipc_open_socket(socket_path);
+        ipc_initialize(bar, bar_id);
+        if (bar->config->status_command) {
+                bar->status = status_line_init(bar->config->status_command);
         }
 
-        free(output);
-}
+        bar->display = wl_display_connect(NULL);
+        assert(bar->display);
 
-static void free_outputs(list_t *outputs) {
-        int i;
-        for (i = 0; i < outputs->length; ++i) {
-                free_output(outputs->items[i]);
+        struct wl_registry *registry = wl_display_get_registry(bar->display);
+        wl_registry_add_listener(registry, &registry_listener, bar);
+        wl_display_roundtrip(bar->display);
+        assert(bar->compositor && bar->layer_shell && bar->shm);
+        wl_display_roundtrip(bar->display);
+
+        struct swaybar_pointer *pointer = &bar->pointer;
+
+        int max_scale = 1;
+        struct swaybar_output *output;
+        wl_list_for_each(output, &bar->outputs, link) {
+                if (output->scale > max_scale) {
+                        max_scale = output->scale;
+                }
         }
-        list_free(outputs);
-}
 
-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);
+        pointer->cursor_theme = wl_cursor_theme_load(
+                                NULL, 24 * max_scale, bar->shm);
+        assert(pointer->cursor_theme);
+        struct wl_cursor *cursor;
+        cursor = wl_cursor_theme_get_cursor(pointer->cursor_theme, "left_ptr");
+        assert(cursor);
+        pointer->cursor_image = cursor->images[0];
+        pointer->cursor_surface = wl_compositor_create_surface(bar->compositor);
+        assert(pointer->cursor_surface);
+
+        wl_list_for_each(output, &bar->outputs, link) {
+                struct config_output *coutput;
+                wl_list_for_each(coutput, &bar->config->outputs, link) {
+                        if (coutput->index == output->index) {
+                                output->name = strdup(coutput->name);
+                                break;
+                        }
                 }
+                output->surface = wl_compositor_create_surface(bar->compositor);
+                assert(output->surface);
+                output->layer_surface = zwlr_layer_shell_v1_get_layer_surface(
+                                bar->layer_shell, output->surface, output->output,
+                                ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM, "panel");
+                assert(output->layer_surface);
+                zwlr_layer_surface_v1_add_listener(output->layer_surface,
+                                &layer_surface_listener, output);
+                zwlr_layer_surface_v1_set_anchor(output->layer_surface,
+                                bar->config->position);
         }
+        ipc_get_workspaces(bar);
+        render_all_frames(bar);
 }
 
-void bar_teardown(struct bar *bar) {
-        if (bar->config) {
-                free_config(bar->config);
+static void display_in(int fd, short mask, void *_bar) {
+        struct swaybar *bar = (struct swaybar *)_bar;
+        if (wl_display_dispatch(bar->display) == -1) {
+                bar_teardown(bar);
+                exit(0);
         }
+}
 
-        if (bar->outputs) {
-                free_outputs(bar->outputs);
+static void ipc_in(int fd, short mask, void *_bar) {
+        struct swaybar *bar = (struct swaybar *)_bar;
+        if (handle_ipc_readable(bar)) {
+                render_all_frames(bar);
         }
+}
 
-        if (bar->status) {
-                free_status_line(bar->status);
+static void status_in(int fd, short mask, void *_bar) {
+        struct swaybar *bar = (struct swaybar *)_bar;
+        if (status_handle_readable(bar->status)) {
+                render_all_frames(bar);
         }
+}
 
-        /* close sockets/pipes */
-        if (bar->status_read_fd) {
-                close(bar->status_read_fd);
+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);
+        if (bar->status) {
+                add_event(bar->status->read_fd, POLLIN, status_in, bar);
         }
-
-        if (bar->status_write_fd) {
-                close(bar->status_write_fd);
+        while (1) {
+                event_loop_poll();
         }
+}
 
-        if (bar->ipc_socketfd) {
-                close(bar->ipc_socketfd);
+static void free_outputs(struct wl_list *list) {
+        struct swaybar_output *output, *tmp;
+        wl_list_for_each_safe(output, tmp, list, link) {
+                wl_list_remove(&output->link);
+                free(output->name);
+                free(output);
         }
+}
 
-        if (bar->ipc_event_socketfd) {
-                close(bar->ipc_event_socketfd);
+void bar_teardown(struct swaybar *bar) {
+        free_outputs(&bar->outputs);
+        if (bar->config) {
+                free_config(bar->config);
+        }
+        close(bar->ipc_event_socketfd);
+        close(bar->ipc_socketfd);
+        if (bar->status) {
+                status_line_free(bar->status);
         }
-
-        /* terminate status command process */
-        terminate_status_command(bar->status_command_pid);
 }
diff --git a/swaybar/config.c b/swaybar/config.c
index 8fe552f2..9169ad27 100644
--- a/swaybar/config.c
+++ b/swaybar/config.c
@@ -1,40 +1,32 @@
 #define _XOPEN_SOURCE 500
 #include <stdlib.h>
 #include <string.h>
-#include "wayland-desktop-shell-client-protocol.h"
-#include "log.h"
 #include "swaybar/config.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
 uint32_t parse_position(const char *position) {
+        uint32_t horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+                ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+        uint32_t vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+                ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
         if (strcmp("top", position) == 0) {
-                return DESKTOP_SHELL_PANEL_POSITION_TOP;
+                return ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | horiz;
         } else if (strcmp("bottom", position) == 0) {
-                return DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
+                return ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | horiz;
         } else if (strcmp("left", position) == 0) {
-                return DESKTOP_SHELL_PANEL_POSITION_LEFT;
+                return ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | vert;
         } else if (strcmp("right", position) == 0) {
-                return DESKTOP_SHELL_PANEL_POSITION_RIGHT;
+                return ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | vert;
         } else {
-                return DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
+                return ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | horiz;
         }
 }
 
-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 config *init_config() {
-        struct config *config = calloc(1, sizeof(struct config));
+struct swaybar_config *init_config() {
+        struct swaybar_config *config = calloc(1, sizeof(struct swaybar_config));
         config->status_command = NULL;
         config->pango_markup = false;
-        config->position = DESKTOP_SHELL_PANEL_POSITION_BOTTOM;
+        config->position = parse_position("bottom");
         config->font = strdup("monospace 10");
         config->mode = NULL;
         config->sep_symbol = NULL;
@@ -42,27 +34,16 @@ struct 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;
 
-#ifdef ENABLE_TRAY
-        config->tray_output = NULL;
-        config->icon_theme = NULL;
-        config->tray_padding = 2;
-        /**
-         * These constants are used by wayland and are defined in
-         * linux/input-event-codes.h
-         */
-        config->activate_button = 0x110; /* BTN_LEFT */
-        config->context_button = 0x111; /* BTN_RIGHT */
-#endif
-
         /* colors */
         config->colors.background = 0x000000FF;
+        config->colors.focused_background = 0x000000FF;
         config->colors.statusline = 0xFFFFFFFF;
+        config->colors.focused_statusline = 0xFFFFFFFF;
         config->colors.separator = 0x666666FF;
 
         config->colors.focused_workspace.border = 0x4C7899FF;
@@ -88,7 +69,7 @@ struct config *init_config() {
         return config;
 }
 
-void free_config(struct config *config) {
+void free_config(struct swaybar_config *config) {
         free(config->status_command);
         free(config->font);
         free(config->mode);
diff --git a/swaybar/event_loop.c b/swaybar/event_loop.c
index 0d1be1da..748372ed 100644
--- a/swaybar/event_loop.c
+++ b/swaybar/event_loop.c
@@ -4,19 +4,18 @@
 #include <string.h>
 #include <strings.h>
 #include <poll.h>
-#include "swaybar/bar.h"
+#include <time.h>
 #include "swaybar/event_loop.h"
 #include "list.h"
-#include "log.h"
 
 struct event_item {
-        void(*cb)(int fd, short mask, void *data);
+        void (*cb)(int fd, short mask, void *data);
         void *data;
 };
 
 struct timer_item {
         timer_t timer;
-        void(*cb)(timer_t timer, void *data);
+        void (*cb)(timer_t timer, void *data);
         void *data;
 };
 
@@ -138,7 +137,8 @@ void event_loop_poll() {
 void init_event_loop() {
         event_loop.fds.length = 0;
         event_loop.fds.capacity = 10;
-        event_loop.fds.items = malloc(event_loop.fds.capacity * sizeof(struct pollfd));
+        event_loop.fds.items = malloc(
+                        event_loop.fds.capacity * sizeof(struct pollfd));
         event_loop.items = create_list();
         event_loop.timers = create_list();
 }
diff --git a/swaybar/i3bar.c b/swaybar/i3bar.c
new file mode 100644
index 00000000..923ad755
--- /dev/null
+++ b/swaybar/i3bar.c
@@ -0,0 +1,215 @@
+#define _POSIX_C_SOURCE 200809L
+#include <json-c/json.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wlr/util/log.h>
+#include "swaybar/config.h"
+#include "swaybar/status_line.h"
+
+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;
+        }
+        wlr_log(L_DEBUG, "Got i3bar json: '%s'", text);
+        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;
+}
+
+bool i3bar_handle_readable(struct status_line *status) {
+        struct i3bar_protocol_state *state = &status->i3bar_state;
+
+        char *cur = &state->buffer[state->buffer_index];
+        ssize_t n = read(status->read_fd, cur,
+                        state->buffer_size - state->buffer_index);
+        if (n == -1) {
+                status_error(status, "[failed to read from status command]");
+                return false;
+        }
+
+        if (n == (ssize_t)(state->buffer_size - state->buffer_index)) {
+                state->buffer_size = state->buffer_size * 2;
+                char *new_buffer = realloc(state->buffer, state->buffer_size);
+                if (!new_buffer) {
+                        free(state->buffer);
+                        status_error(status, "[failed to allocate buffer]");
+                        return true;
+                }
+                state->current_node += new_buffer - state->buffer;
+                cur += new_buffer - state->buffer;
+                state->buffer = new_buffer;
+        }
+
+        cur[n] = '\0';
+        bool redraw = false;
+        while (*cur) {
+                if (state->nodes[state->depth] == JSON_NODE_STRING) {
+                        if (!state->escape && *cur == '"') {
+                                --state->depth;
+                        }
+                        state->escape = !state->escape && *cur == '\\';
+                } else {
+                        switch (*cur) {
+                        case '[':
+                                ++state->depth;
+                                if (state->depth >
+                                                sizeof(state->nodes) / sizeof(state->nodes[0])) {
+                                        status_error(status, "[i3bar json too deep]");
+                                        return false;
+                                }
+                                state->nodes[state->depth] = JSON_NODE_ARRAY;
+                                if (state->depth == 1) {
+                                        state->current_node = cur;
+                                }
+                                break;
+                        case ']':
+                                if (state->nodes[state->depth] != JSON_NODE_ARRAY) {
+                                        status_error(status, "[failed to parse i3bar json]");
+                                        return false;
+                                }
+                                --state->depth;
+                                if (state->depth == 0) {
+                                        // cur[1] is valid since cur[0] != '\0'
+                                        char p = cur[1];
+                                        cur[1] = '\0';
+                                        redraw = i3bar_parse_json(
+                                                        status, state->current_node) || redraw;
+                                        cur[1] = p;
+                                        memmove(state->buffer, cur,
+                                                        state->buffer_size - (cur - state->buffer));
+                                        cur = state->buffer;
+                                        state->current_node = cur + 1;
+                                }
+                                break;
+                        case '"':
+                                ++state->depth;
+                                if (state->depth >
+                                                sizeof(state->nodes) / sizeof(state->nodes[0])) {
+                                        status_error(status, "[i3bar json too deep]");
+                                        return false;
+                                }
+                                state->nodes[state->depth] = JSON_NODE_STRING;
+                                break;
+                        }
+                }
+                ++cur;
+        }
+        state->buffer_index = cur - state->buffer;
+        return redraw;
+}
+
+void i3bar_block_send_click(struct status_line *status,
+                struct i3bar_block *block, int x, int y, uint32_t button) {
+        wlr_log(L_DEBUG, "block %s clicked", block->name ? block->name : "(nil)");
+        if (!block->name || !status->i3bar_state.click_events) {
+                return;
+        }
+
+        struct json_object *event_json = json_object_new_object();
+        json_object_object_add(event_json, "name",
+                        json_object_new_string(block->name));
+        if (block->instance) {
+                json_object_object_add(event_json, "instance",
+                                json_object_new_string(block->instance));
+        }
+
+        json_object_object_add(event_json, "button", json_object_new_int(button));
+        json_object_object_add(event_json, "x", json_object_new_int(x));
+        json_object_object_add(event_json, "y", json_object_new_int(y));
+        if (dprintf(status->write_fd, "%s\n",
+                                json_object_to_json_string(event_json)) < 0) {
+                status_error(status, "[failed to write click event]");
+        }
+        json_object_put(event_json);
+}
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index 93d1219c..ed5d9a31 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -1,37 +1,140 @@
 #define _XOPEN_SOURCE 500
+#include <limits.h>
 #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"
-#include "list.h"
-#include "log.h"
-
-void ipc_send_workspace_command(const char *workspace_name) {
-        uint32_t size = strlen("workspace \"\"") + strlen(workspace_name) + 1;
 
+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];
-        sprintf(command, "workspace \"%s\"", workspace_name);
+        snprintf(command, size, fmt, ws);
+        ipc_single_command(bar->ipc_socketfd, IPC_COMMAND, command, &size);
+}
 
-        ipc_single_command(swaybar.ipc_socketfd, IPC_COMMAND, command, &size);
+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_config(struct config *config, const char *payload) {
+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;
-#ifdef ENABLE_TRAY
-        json_object *tray_output, *icon_theme, *tray_padding, *activate_button, *context_button;
-        json_object *secondary_button;
-        json_object_object_get_ex(bar_config, "tray_output", &tray_output);
-        json_object_object_get_ex(bar_config, "icon_theme", &icon_theme);
-        json_object_object_get_ex(bar_config, "tray_padding", &tray_padding);
-        json_object_object_get_ex(bar_config, "activate_button", &activate_button);
-        json_object_object_get_ex(bar_config, "context_button", &context_button);
-        json_object_object_get_ex(bar_config, "secondary_button", &secondary_button);
-#endif
         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);
@@ -47,230 +150,100 @@ static void ipc_parse_config(struct config *config, const char *payload) {
         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);
         }
 
-#ifdef ENABLE_TRAY
-        if (tray_output) {
-                free(config->tray_output);
-                config->tray_output = strdup(json_object_get_string(tray_output));
-        }
-
-        if (icon_theme) {
-                free(config->icon_theme);
-                config->icon_theme = strdup(json_object_get_string(icon_theme));
-        }
-
-        if (tray_padding) {
-                config->tray_padding = json_object_get_int(tray_padding);
-        }
-
-        if (activate_button) {
-                config->activate_button = json_object_get_int(activate_button);
-        }
-
-        if (context_button) {
-                config->context_button = json_object_get_int(context_button);
+        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 (secondary_button) {
-                config->secondary_button = json_object_get_int(secondary_button);
-        }
-#endif
-
-        // free previous outputs list
-        int i;
-        for (i = 0; i < config->outputs->length; ++i) {
-                free(config->outputs->items[i]);
-        }
-        list_free(config->outputs);
-        config->outputs = create_list();
-
         if (outputs) {
                 int length = json_object_array_length(outputs);
-                json_object *output;
-                const char *output_str;
-                for (i = 0; i < length; ++i) {
-                        output = json_object_array_get_idx(outputs, i);
-                        output_str = json_object_get_string(output);
-                        if (strcmp("*", output_str) == 0) {
+                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) {
                                 config->all_outputs = true;
                                 break;
                         }
-                        list_add(config->outputs, strdup(output_str));
+                        struct config_output *coutput = calloc(
+                                        1, sizeof(struct config_output));
+                        coutput->name = strdup(name);
+                        coutput->index = SIZE_MAX;
+                        wl_list_insert(&config->outputs, &coutput->link);
                 }
         } else {
                 config->all_outputs = true;
         }
 
         if (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));
-                }
+                ipc_parse_colors(config, colors);
         }
 
         json_object_put(bar_config);
 }
 
-static void ipc_update_workspaces(struct bar *bar) {
-        int i;
-        for (i = 0; i < bar->outputs->length; ++i) {
-                struct output *output = bar->outputs->items[i];
-                if (output->workspaces) {
-                        free_workspaces(output->workspaces);
-                }
-                output->workspaces = create_list();
+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) {
+        bar->focused_output = NULL;
+        struct swaybar_output *output;
+        wl_list_for_each(output, &bar->outputs, link) {
+                free_workspaces(&output->workspaces);
+                output->focused = false;
+        }
         uint32_t len = 0;
-        char *res = ipc_single_command(bar->ipc_socketfd, IPC_GET_WORKSPACES, NULL, &len);
+        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 length = json_object_array_length(results);
+        size_t length = json_object_array_length(results);
         json_object *ws_json;
         json_object *num, *name, *visible, *focused, *out, *urgent;
-        for (i = 0; i < length; ++i) {
+        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);
@@ -280,113 +253,95 @@ static void ipc_update_workspaces(struct bar *bar) {
                 json_object_object_get_ex(ws_json, "output", &out);
                 json_object_object_get_ex(ws_json, "urgent", &urgent);
 
-                int j;
-                for (j = 0; j < bar->outputs->length; ++j) {
-                        struct output *output = bar->outputs->items[j];
-                        if (strcmp(json_object_get_string(out), output->name) == 0) {
-                                struct workspace *ws = malloc(sizeof(struct workspace));
+                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);
-                                list_add(output->workspaces, ws);
+                                wl_list_insert(&output->workspaces, &ws->link);
                         }
                 }
         }
-
         json_object_put(results);
         free(res);
 }
 
-void ipc_bar_init(struct bar *bar, const char *bar_id) {
-        // Get bar config
-        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);
-
-        // Get outputs
-        len = 0;
-        res = ipc_single_command(bar->ipc_socketfd, IPC_GET_OUTPUTS, NULL, &len);
+static void ipc_get_outputs(struct swaybar *bar) {
+        uint32_t len = 0;
+        char *res = ipc_single_command(bar->ipc_socketfd,
+                        IPC_GET_OUTPUTS, NULL, &len);
         json_object *outputs = json_tokener_parse(res);
-        int i;
-        int length = json_object_array_length(outputs);
-        json_object *output, *output_name, *output_active;
-        const char *name;
-        bool active;
-        for (i = 0; i < length; ++i) {
-                output = json_object_array_get_idx(outputs, i);
+        for (size_t i = 0; i < json_object_array_length(outputs); ++i) {
+                json_object *output = json_object_array_get_idx(outputs, i);
+                json_object *output_name, *output_active;
                 json_object_object_get_ex(output, "name", &output_name);
                 json_object_object_get_ex(output, "active", &output_active);
-                name = json_object_get_string(output_name);
-                active = json_object_get_boolean(output_active);
+                const char *name = json_object_get_string(output_name);
+                bool active = json_object_get_boolean(output_active);
                 if (!active) {
                         continue;
                 }
-
-                bool use_output = false;
                 if (bar->config->all_outputs) {
-                        use_output = true;
+                        struct config_output *coutput = calloc(
+                                        1, sizeof(struct config_output));
+                        coutput->name = strdup(name);
+                        coutput->index = i;
+                        wl_list_insert(&bar->config->outputs, &coutput->link);
                 } else {
-                        int j = 0;
-                        for (j = 0; j < bar->config->outputs->length; ++j) {
-                                const char *conf_name = bar->config->outputs->items[j];
-                                if (strcasecmp(name, conf_name) == 0) {
-                                        use_output = true;
+                        struct config_output *coutput;
+                        wl_list_for_each(coutput, &bar->config->outputs, link) {
+                                if (strcmp(name, coutput->name) == 0) {
+                                        coutput->index = i;
                                         break;
                                 }
                         }
                 }
-
-                if (!use_output) {
-                        continue;
-                }
-
-                // add bar to the output
-                struct output *bar_output = new_output(name);
-                bar_output->idx = i;
-                list_add(bar->outputs, bar_output);
         }
-        free(res);
         json_object_put(outputs);
+        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);
+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);
 
-        ipc_update_workspaces(bar);
+        const char *subscribe = "[ \"workspace\", \"mode\" ]";
+        len = strlen(subscribe);
+        free(ipc_single_command(bar->ipc_event_socketfd,
+                        IPC_SUBSCRIBE, subscribe, &len));
 }
 
-bool handle_ipc_event(struct bar *bar) {
+bool handle_ipc_readable(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_update_workspaces(bar);
+                ipc_get_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");
+                        wlr_log(L_ERROR, "failed to parse payload as json");
                         return false;
                 }
-                json_object *json_change;
+                json_object *json_change, *json_pango_markup;
                 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;
@@ -394,9 +349,16 @@ bool handle_ipc_event(struct bar *bar) {
                                 bar->config->mode = strdup(change);
                         }
                 } else {
-                        sway_log(L_ERROR, "failed to parse response");
+                        wlr_log(L_ERROR, "failed to parse response");
+                        json_object_put(result);
+                        free_ipc_response(resp);
+                        return false;
+                }
+                if (json_object_object_get_ex(result,
+                                        "pango_markup", &json_pango_markup)) {
+                        bar->config->mode_pango_markup = json_object_get_boolean(
+                                        json_pango_markup);
                 }
-
                 json_object_put(result);
                 break;
         }
@@ -404,7 +366,6 @@ bool handle_ipc_event(struct bar *bar) {
                 free_ipc_response(resp);
                 return false;
         }
-
         free_ipc_response(resp);
         return true;
 }
diff --git a/swaybar/main.c b/swaybar/main.c
index 0abd0755..c897e1c9 100644
--- a/swaybar/main.c
+++ b/swaybar/main.c
@@ -4,21 +4,20 @@
 #include <string.h>
 #include <stdbool.h>
 #include <getopt.h>
+#include <wlr/util/log.h>
 #include "swaybar/bar.h"
 #include "ipc-client.h"
-#include "log.h"
 
-/* global bar state */
-struct bar swaybar;
+static struct swaybar swaybar;
 
-void sway_terminate(int exit_code) {
+void sig_handler(int signal) {
         bar_teardown(&swaybar);
-        exit(exit_code);
+        exit(0);
 }
 
-void sig_handler(int signal) {
+void sway_terminate(int code) {
         bar_teardown(&swaybar);
-        exit(0);
+        exit(code);
 }
 
 int main(int argc, char **argv) {
@@ -75,20 +74,23 @@ int main(int argc, char **argv) {
                 }
         }
 
-        if (!bar_id) {
-                sway_abort("No bar_id passed. Provide --bar_id or let sway start swaybar");
-        }
-
         if (debug) {
-                init_log(L_DEBUG);
+                wlr_log_init(L_DEBUG, NULL);
         } else {
-                init_log(L_ERROR);
+                wlr_log_init(L_ERROR, NULL);
+        }
+
+        if (!bar_id) {
+                wlr_log(L_ERROR, "No bar_id passed. "
+                                "Provide --bar_id or let sway start swaybar");
+                return 1;
         }
 
         if (!socket_path) {
                 socket_path = get_socketpath();
                 if (!socket_path) {
-                        sway_abort("Unable to retrieve socket path");
+                        wlr_log(L_ERROR, "Unable to retrieve socket path");
+                        return 1;
                 }
         }
 
@@ -100,9 +102,6 @@ int main(int argc, char **argv) {
         free(bar_id);
 
         bar_run(&swaybar);
-
-        // gracefully shutdown swaybar and status_command
         bar_teardown(&swaybar);
-
         return 0;
 }
diff --git a/swaybar/meson.build b/swaybar/meson.build
new file mode 100644
index 00000000..d65edb11
--- /dev/null
+++ b/swaybar/meson.build
@@ -0,0 +1,28 @@
+executable(
+        'swaybar', [
+                'bar.c',
+                'config.c',
+                'event_loop.c',
+                'i3bar.c',
+                'ipc.c',
+                'main.c',
+                'render.c',
+                'status_line.c',
+        ],
+        include_directories: [sway_inc],
+        dependencies: [
+                cairo,
+                client_protos,
+                gdk_pixbuf,
+                jsonc,
+                math,
+                pango,
+                pangocairo,
+                rt,
+                wayland_client,
+                wayland_cursor,
+                wlroots,
+        ],
+        link_with: [lib_sway_common, lib_sway_client],
+        install: true
+)
diff --git a/swaybar/render.c b/swaybar/render.c
index 6fc09078..26248d35 100644
--- a/swaybar/render.c
+++ b/swaybar/render.c
@@ -1,35 +1,92 @@
+#define _POSIX_C_SOURCE 200809L
+#include <limits.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
-
-#include "client/cairo.h"
-#include "client/pango.h"
-#include "client/window.h"
+#include <wlr/util/log.h>
+#include "cairo.h"
+#include "pango.h"
+#include "pool-buffer.h"
+#include "swaybar/bar.h"
 #include "swaybar/config.h"
-#include "swaybar/status_line.h"
+#include "swaybar/ipc.h"
 #include "swaybar/render.h"
-#ifdef ENABLE_TRAY
-#include "swaybar/tray/tray.h"
-#include "swaybar/tray/sni.h"
-#endif
-#include "log.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;
-
-/**
- * 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);
+#include "swaybar/status_line.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+
+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_output *output, struct swaybar_config *config,
+                const char *error, double *x, uint32_t surface_height) {
+        if (!error) {
+                return 0;
+        }
+
+        uint32_t height = surface_height * output->scale;
+
+        cairo_set_source_u32(cairo, 0xFF0000FF);
+
+        int margin = 3 * output->scale;
+        int ws_vertical_padding = WS_VERTICAL_PADDING * output->scale;
+
+        int text_width, text_height;
+        get_text_size(cairo, config->font,
+                        &text_width, &text_height, output->scale, false, "%s", error);
+
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2;
+        uint32_t ideal_surface_height = ideal_height / output->scale;
+        if (surface_height < ideal_surface_height) {
+                return ideal_surface_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, output->scale, false, "%s", error);
+        *x -= margin;
+        return surface_height;
+}
+
+static uint32_t render_status_line_text(cairo_t *cairo,
+                struct swaybar_output *output, struct swaybar_config *config,
+                const char *text, bool focused, double *x, uint32_t surface_height) {
+        if (!text) {
+                return 0;
+        }
+
+        uint32_t height = surface_height * output->scale;
+
+        cairo_set_source_u32(cairo, focused ?
+                        config->colors.focused_statusline : config->colors.statusline);
 
+        int text_width, text_height;
+        get_text_size(cairo, config->font, &text_width, &text_height,
+                        output->scale, config->pango_markup, "%s", text);
+
+        int ws_vertical_padding = WS_VERTICAL_PADDING * output->scale;
+        int margin = 3 * output->scale;
+
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2;
+        uint32_t ideal_surface_height = ideal_height / output->scale;
+        if (surface_height < ideal_surface_height) {
+                return ideal_surface_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, output->scale,
+                        config->pango_markup, "%s", text);
+        *x -= margin;
+        return surface_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);
@@ -39,13 +96,11 @@ static void render_sharp_line(cairo_t *cairo, uint32_t color, double x, double y
                         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);
@@ -53,176 +108,256 @@ static void render_sharp_line(cairo_t *cairo, uint32_t color, double x, double y
         }
 }
 
-static void render_block(struct window *window, struct config *config, struct status_block *block, double *x, bool edge, bool is_focused) {
-        int width, height, sep_width;
-        get_text_size(window->cairo, window->font, &width, &height,
-                        window->scale, block->markup, "%s", block->full_text);
+static void block_hotspot_callback(struct swaybar_output *output,
+                        int x, int y, uint32_t button, void *data) {
+        struct i3bar_block *block = data;
+        struct status_line *status = output->bar->status;
+        i3bar_block_send_click(status, block, x, y, button);
+}
 
-        int textwidth = width;
-        double block_width = width;
+static uint32_t render_status_block(cairo_t *cairo,
+                struct swaybar_config *config, struct swaybar_output *output,
+                struct i3bar_block *block, double *x,
+                uint32_t surface_height, bool focused, bool edge) {
+        if (!block->full_text || !*block->full_text) {
+                return 0;
+        }
 
+        uint32_t height = surface_height * output->scale;
+
+        int text_width, text_height;
+        get_text_size(cairo, config->font, &text_width, &text_height,
+                        output->scale, block->markup, "%s", block->full_text);
+
+        int margin = 3 * output->scale;
+        int ws_vertical_padding = WS_VERTICAL_PADDING * 2;
+
+        int width = text_width;
         if (width < block->min_width) {
                 width = block->min_width;
         }
 
-        *x -= width;
+        double block_width = width;
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2;
+        uint32_t ideal_surface_height = ideal_height / output->scale;
+        if (surface_height < ideal_surface_height) {
+                return ideal_surface_height;
+        }
 
-        if (block->border != 0 && block->border_left > 0) {
+        *x -= width;
+        if (block->border && block->border_left > 0) {
                 *x -= (block->border_left + margin);
                 block_width += block->border_left + margin;
         }
-
-        if (block->border != 0 && block->border_right > 0) {
+        if (block->border && block->border_right > 0) {
                 *x -= (block->border_right + margin);
                 block_width += block->border_right + margin;
         }
 
-        // Add separator
+        int sep_width, sep_height;
         if (!edge) {
                 if (config->sep_symbol) {
-                        get_text_size(window->cairo, window->font, &sep_width, &height,
-                                        window->scale, false, "%s", config->sep_symbol);
+                        get_text_size(cairo, config->font, &sep_width, &sep_height,
+                                        output->scale, false, "%s", config->sep_symbol);
+                        uint32_t _ideal_height = sep_height + ws_vertical_padding * 2;
+                        uint32_t _ideal_surface_height = _ideal_height / output->scale;
+                        if (surface_height < _ideal_surface_height) {
+                                return _ideal_surface_height;
+                        }
                         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;
-
-        block->x = (int)pos;
-        block->width = (int)block_width;
+        struct swaybar_hotspot *hotspot = calloc(1, sizeof(struct swaybar_hotspot));
+        hotspot->x = *x;
+        hotspot->y = 0;
+        hotspot->width = width;
+        hotspot->height = height;
+        hotspot->callback = block_hotspot_callback;
+        hotspot->destroy = NULL;
+        hotspot->data = block;
+        wl_list_insert(&output->hotspots, &hotspot->link);
 
-        // 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 * window->scale) - 2);
-                cairo_fill(window->cairo);
+        double pos = *x;
+        if (block->background) {
+                cairo_set_source_u32(cairo, block->background);
+                cairo_rectangle(cairo, pos - 0.5 * output->scale,
+                                output->scale, block_width, height);
+                cairo_fill(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);
+        if (block->border && block->border_top > 0) {
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5 * output->scale, output->scale,
+                                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 * window->scale) - 1 - block->border_bottom,
-                                block_width,
-                                block->border_bottom);
+        if (block->border && block->border_bottom > 0) {
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5 * output->scale,
+                                height - output->scale - 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 * window->scale) - 2);
-
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5 * output->scale, output->scale,
+                                block->border_left, height);
                 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;
+                offset = pos + width - text_width;
         } else if (strncmp(block->align, "center", 6) == 0) {
-                offset = pos + (width - textwidth) / 2;
+                offset = pos + (width - text_width) / 2;
         }
-
-        cairo_move_to(window->cairo, offset, margin);
-        cairo_set_source_u32(window->cairo, block->color);
-        pango_printf(window->cairo, window->font, window->scale,
+        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, output->scale,
                         block->markup, "%s", block->full_text);
-
         pos += width;
 
-        // render right border
-        if (block->border != 0 && block->border_right > 0) {
+        if (block->border && block->border_right > 0) {
                 pos += margin;
-
-                render_sharp_line(window->cairo, block->border,
-                                pos - 0.5,
-                                1,
-                                block->border_right,
-                                (window->height * window->scale) - 2);
-
+                render_sharp_line(cairo, block->border,
+                                pos - 0.5 * output->scale, output->scale,
+                                block->border_right, height);
                 pos += block->border_right;
         }
 
-        // render separator
         if (!edge && block->separator) {
-                if (is_focused) {
-                        cairo_set_source_u32(window->cairo, config->colors.focused_separator);
+                if (focused) {
+                        cairo_set_source_u32(cairo, config->colors.focused_separator);
                 } else {
-                        cairo_set_source_u32(window->cairo, config->colors.separator);
+                        cairo_set_source_u32(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->cairo, window->font, window->scale,
-                                        false, "%s", config->sep_symbol);
+                        cairo_move_to(cairo, offset, height / 2.0 - sep_height / 2.0);
+                        pango_printf(cairo, config->font, output->scale, false,
+                                        "%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 * window->scale) - margin);
-                        cairo_stroke(window->cairo);
+                        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 surface_height;
+}
 
+static uint32_t render_status_line_i3bar(cairo_t *cairo,
+                struct swaybar_config *config, struct swaybar_output *output,
+                struct status_line *status, bool focused,
+                double *x, uint32_t surface_height) {
+        uint32_t max_height = 0;
+        bool edge = true;
+        struct i3bar_block *block;
+        wl_list_for_each(block, &status->blocks, link) {
+                uint32_t h = render_status_block(cairo, config, output,
+                                block, x, surface_height, focused, edge);
+                max_height = h > max_height ? h : max_height;
+                edge = false;
+        }
+        return max_height;
 }
 
-static const char *strip_workspace_name(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;
-                        }
-                }
+static uint32_t render_status_line(cairo_t *cairo,
+                struct swaybar_config *config, struct swaybar_output *output,
+                struct status_line *status, bool focused,
+                double *x, uint32_t surface_height) {
+        switch (status->protocol) {
+        case PROTOCOL_ERROR:
+                return render_status_line_error(cairo, output, config,
+                                status->text, x, surface_height);
+        case PROTOCOL_TEXT:
+                return render_status_line_text(cairo, output, config,
+                                status->text, focused, x, surface_height);
+        case PROTOCOL_I3BAR:
+                return render_status_line_i3bar(cairo, config, output,
+                                status, focused, x, surface_height);
+        case PROTOCOL_UNDEF:
+                return 0;
         }
+        return 0;
+}
+
+static uint32_t render_binding_mode_indicator(cairo_t *cairo,
+                struct swaybar_output *output, struct swaybar_config *config,
+                const char *mode, double x, uint32_t surface_height) {
+        uint32_t height = surface_height * output->scale;
 
-        if (strip) {
-                return ws_name + i;
+        int text_width, text_height;
+        get_text_size(cairo, config->font, &text_width, &text_height,
+                        output->scale, true, "%s", mode);
+
+        int ws_vertical_padding = WS_VERTICAL_PADDING * output->scale;
+        int ws_horizontal_padding = WS_HORIZONTAL_PADDING * output->scale;
+        int border_width = BORDER_WIDTH * output->scale;
+
+        uint32_t ideal_height = text_height + ws_vertical_padding * 2
+                + border_width * 2;
+        uint32_t ideal_surface_height = ideal_height / output->scale;
+        if (surface_height < ideal_surface_height) {
+                return ideal_surface_height;
         }
+        uint32_t width = text_width + ws_horizontal_padding * 2 + border_width * 2;
+
+        cairo_set_source_u32(cairo, config->colors.binding_mode.background);
+        cairo_rectangle(cairo, x, 0, width, height);
+        cairo_fill(cairo);
+
+        cairo_set_source_u32(cairo, config->colors.binding_mode.border);
+        cairo_rectangle(cairo, x, 0, width, border_width);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, x, 0, border_width, height);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, x + width - border_width, 0, border_width, height);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, x, height - border_width, width, border_width);
+        cairo_fill(cairo);
+
+        double text_y = height / 2.0 - text_height / 2.0;
+        cairo_set_source_u32(cairo, config->colors.binding_mode.text);
+        cairo_move_to(cairo, x + width / 2 - text_width / 2, (int)floor(text_y));
+        pango_printf(cairo, config->font, output->scale, true, "%s", mode);
+        return surface_height;
+}
 
+static const char *strip_workspace_number(const char *ws_name) {
+        size_t len = strlen(ws_name);
+        for (size_t i = 0; i < len; ++i) {
+                if (ws_name[i] < '0' || ws_name[i] > '9') {
+                        if (':' == ws_name[i] && i < len - 1 && i > 0) {
+                                return ws_name + i + 1;
+                        }
+                        return ws_name;
+                }
+        }
         return ws_name;
 }
 
-void workspace_button_size(struct window *window, const char *workspace_name, int *width, int *height) {
-        const char *stripped_name = strip_workspace_name(swaybar.config->strip_workspace_numbers, workspace_name);
-
-        get_text_size(window->cairo, window->font, width, height,
-                        window->scale, true, "%s", stripped_name);
-        *width += 2 * ws_horizontal_padding;
-        *height += 2 * ws_vertical_padding;
+static void workspace_hotspot_callback(struct swaybar_output *output,
+                        int x, int y, uint32_t button, void *data) {
+        ipc_send_workspace_command(output->bar, (const char *)data);
 }
 
-static void render_workspace_button(struct window *window, struct config *config, struct workspace *ws, double *x) {
-        const char *stripped_name = strip_workspace_name(config->strip_workspace_numbers, ws->name);
+static uint32_t render_workspace_button(cairo_t *cairo,
+                struct swaybar_output *output, struct swaybar_config *config,
+                struct swaybar_workspace *ws, double *x, uint32_t surface_height) {
+        const char *name = ws->name;
+        if (config->strip_workspace_numbers) {
+                name = strip_workspace_number(ws->name);
+        }
 
         struct box_colors box_colors;
         if (ws->urgent) {
@@ -235,133 +370,154 @@ static void render_workspace_button(struct window *window, struct config *config
                 box_colors = config->colors.inactive_workspace;
         }
 
-        int width, height;
-        workspace_button_size(window, stripped_name, &width, &height);
+        uint32_t height = surface_height * output->scale;
 
-        // background
-        cairo_set_source_u32(window->cairo, box_colors.background);
-        cairo_rectangle(window->cairo, *x, 1.5, width - 1, height);
-        cairo_fill(window->cairo);
-
-        // border
-        cairo_set_source_u32(window->cairo, box_colors.border);
-        cairo_rectangle(window->cairo, *x, 1.5, width - 1, height);
-        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->cairo, window->font, window->scale,
-                        true, "%s", stripped_name);
-
-        *x += width + ws_spacing;
-}
+        int text_width, text_height;
+        get_text_size(cairo, config->font, &text_width, &text_height,
+                        output->scale, true, "%s", name);
+
+        int ws_vertical_padding = WS_VERTICAL_PADDING * output->scale;
+        int ws_horizontal_padding = WS_HORIZONTAL_PADDING * output->scale;
+        int border_width = BORDER_WIDTH * output->scale;
+
+        uint32_t ideal_height = ws_vertical_padding * 2 + text_height
+                + border_width * 2;
+        uint32_t ideal_surface_height = ideal_height / output->scale;
+        if (surface_height < ideal_surface_height) {
+                return ideal_surface_height;
+        }
 
-static void render_binding_mode_indicator(struct window *window, struct config *config, double pos) {
-        int width, height;
-        get_text_size(window->cairo, window->font, &width, &height,
-                        window->scale, false, "%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->cairo, window->font, window->scale,
-                        false, "%s", config->mode);
+        uint32_t width = ws_horizontal_padding * 2 + text_width + border_width * 2;
+
+        cairo_set_source_u32(cairo, box_colors.background);
+        cairo_rectangle(cairo, *x, 0, width, height);
+        cairo_fill(cairo);
+
+        cairo_set_source_u32(cairo, box_colors.border);
+        cairo_rectangle(cairo, *x, 0, width, border_width);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, *x, 0, border_width, height);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, *x + width - border_width, 0, border_width, height);
+        cairo_fill(cairo);
+        cairo_rectangle(cairo, *x, height - border_width, width, border_width);
+        cairo_fill(cairo);
+
+        double text_y = height / 2.0 - text_height / 2.0;
+        cairo_set_source_u32(cairo, box_colors.text);
+        cairo_move_to(cairo, *x + width / 2 - text_width / 2, (int)floor(text_y));
+        pango_printf(cairo, config->font, output->scale, true, "%s", name);
+
+        struct swaybar_hotspot *hotspot = calloc(1, sizeof(struct swaybar_hotspot));
+        hotspot->x = *x;
+        hotspot->y = 0;
+        hotspot->width = width;
+        hotspot->height = height;
+        hotspot->callback = workspace_hotspot_callback;
+        hotspot->destroy = free;
+        hotspot->data = strdup(ws->name);
+        wl_list_insert(&output->hotspots, &hotspot->link);
+
+        *x += width;
+        return surface_height;
 }
 
-void render(struct output *output, struct config *config, struct status_line *line) {
-        int i;
-
-        struct window *window = output->window;
-        cairo_t *cairo = window->cairo;
-        bool is_focused = output->focused;
-
-        // Clear
-        cairo_save(cairo);
-        cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR);
-        cairo_paint(cairo);
-        cairo_restore(cairo);
-
+static uint32_t render_to_cairo(cairo_t *cairo,
+                struct swaybar *bar, struct swaybar_output *output) {
+        struct swaybar_config *config = bar->config;
         cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
-
-        // Background
-        if (is_focused) {
+        if (output->focused) {
                 cairo_set_source_u32(cairo, config->colors.focused_background);
         } else {
                 cairo_set_source_u32(cairo, config->colors.background);
         }
         cairo_paint(cairo);
 
-#ifdef ENABLE_TRAY
-        uint32_t tray_width = tray_render(output, config);
-#else
-        const uint32_t tray_width = window->width * window->scale;
-#endif
-
-        // Command output
-        if (is_focused) {
-                cairo_set_source_u32(cairo, config->colors.focused_statusline);
-        } else {
-                cairo_set_source_u32(cairo, config->colors.statusline);
-        }
-
-        int width, height;
-
-        if (line->protocol == TEXT) {
-                get_text_size(window->cairo, window->font, &width, &height,
-                                window->scale, config->pango_markup, "%s", line->text_line);
-                cairo_move_to(cairo, tray_width - margin - width, margin);
-                pango_printf(window->cairo, window->font, window->scale,
-                                config->pango_markup, "%s", line->text_line);
-        } else if (line->protocol == I3BAR && line->block_line) {
-                double pos = tray_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, is_focused);
-                                edge = false;
-                        }
+        uint32_t max_height = 0;
+        /*
+         * Each render_* function takes the actual height of the bar, and returns
+         * the ideal height. If the actual height is too short, the render function
+         * can do whatever it wants - the buffer won't be committed. If the actual
+         * height is too tall, the render function should adapt its drawing to
+         * utilize the available space.
+         */
+        double x = output->width * output->scale;
+        if (bar->status) {
+                uint32_t h = render_status_line(cairo, config, output,
+                                bar->status, output->focused, &x, output->height);
+                max_height = h > max_height ? h : max_height;
+        }
+        x = 0;
+        if (config->workspace_buttons) {
+                struct swaybar_workspace *ws;
+                wl_list_for_each_reverse(ws, &output->workspaces, link) {
+                        uint32_t h = render_workspace_button(cairo,
+                                        output, config, ws, &x, output->height);
+                        max_height = h > max_height ? h : max_height;
                 }
         }
+        if (config->binding_mode_indicator && config->mode) {
+                uint32_t h = render_binding_mode_indicator(cairo,
+                                output, config, config->mode, x, output->height);
+                max_height = h > max_height ? h : max_height;
+        }
 
-        cairo_set_line_width(cairo, 1.0);
-        double x = 0.5;
+        return max_height > output->height ? max_height : output->height;
+}
 
-        // 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);
+void render_frame(struct swaybar *bar, struct swaybar_output *output) {
+        struct swaybar_hotspot *hotspot, *tmp;
+        wl_list_for_each_safe(hotspot, tmp, &output->hotspots, link) {
+                if (hotspot->destroy) {
+                        hotspot->destroy(hotspot->data);
                 }
+                wl_list_remove(&hotspot->link);
+                free(hotspot);
         }
 
-        // binding mode indicator
-        if (config->mode && config->binding_mode_indicator) {
-                render_binding_mode_indicator(window, config, x);
+        cairo_surface_t *recorder = cairo_recording_surface_create(
+                        CAIRO_CONTENT_COLOR_ALPHA, NULL);
+        cairo_t *cairo = cairo_create(recorder);
+        cairo_save(cairo);
+        cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR);
+        cairo_paint(cairo);
+        cairo_restore(cairo);
+        uint32_t height = render_to_cairo(cairo, bar, output);
+        if (bar->config->height >= 0 && height < (uint32_t)bar->config->height) {
+                height = bar->config->height;
         }
-}
-
-void set_window_height(struct window *window, int height) {
-        int text_width, text_height;
-        get_text_size(window->cairo, window->font,
-                        &text_width, &text_height, window->scale, false,
-                        "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) / window->scale;
+        if (height != output->height) {
+                // Reconfigure surface
+                zwlr_layer_surface_v1_set_size(output->layer_surface, 0, height);
+                zwlr_layer_surface_v1_set_exclusive_zone(output->layer_surface, height);
+                // TODO: this could infinite loop if the compositor assigns us a
+                // different height than what we asked for
+                wl_surface_commit(output->surface);
+                wl_display_roundtrip(bar->display);
+        } else {
+                // Replay recording into shm and send it off
+                output->current_buffer = get_next_buffer(bar->shm,
+                                output->buffers,
+                                output->width * output->scale,
+                                output->height * output->scale);
+                cairo_t *shm = output->current_buffer->cairo;
+
+                cairo_save(shm);
+                cairo_set_operator(shm, CAIRO_OPERATOR_CLEAR);
+                cairo_paint(shm);
+                cairo_restore(shm);
+
+                cairo_set_source_surface(shm, recorder, 0.0, 0.0);
+                cairo_paint(shm);
+
+                wl_surface_set_buffer_scale(output->surface, output->scale);
+                wl_surface_attach(output->surface,
+                                output->current_buffer->buffer, 0, 0);
+                wl_surface_damage(output->surface, 0, 0,
+                                output->width, output->height);
+                wl_surface_commit(output->surface);
+                wl_display_roundtrip(bar->display);
+        }
+        cairo_surface_destroy(recorder);
+        cairo_destroy(cairo);
 }
diff --git a/swaybar/status_line.c b/swaybar/status_line.c
index 87e90caf..8afe4707 100644
--- a/swaybar/status_line.c
+++ b/swaybar/status_line.c
@@ -1,530 +1,130 @@
-#define _XOPEN_SOURCE 700
+#define _POSIX_C_SOURCE
+#include <fcntl.h>
+#include <json-c/json.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 #include <unistd.h>
-#include <json-c/json.h>
-
+#include <wlr/util/log.h>
 #include "swaybar/config.h"
 #include "swaybar/status_line.h"
-#include "log.h"
-#include "util.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 char event_buff[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, *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 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);
-                }
+#include "readline.h"
 
-                if (name) {
-                        new->name = strdup(json_object_get_string(name));
-                }
-
-                if (instance) {
-                        new->instance = strdup(json_object_get_string(instance));
-                }
-
-                if (markup) {
-                        new->markup = false;
-                        const char *markup_str = json_object_get_string(markup);
-                        if (strcmp(markup_str, "pango") == 0) {
-                                new->markup = true;
-                        }
-                }
-
-                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);
+void status_error(struct status_line *status, const char *text) {
+        close(status->read_fd);
+        close(status->write_fd);
+        status->protocol = PROTOCOL_ERROR;
+        status->text = text;
 }
 
-// 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 status_line_mouse_event(struct bar *bar, int x, int y, uint32_t button) {
-        sway_log(L_DEBUG, "status_line_mouse_event.");
-        if (!bar->status->click_events) {
-                sway_log(L_DEBUG, "click_events are not enabled.");
+bool status_handle_readable(struct status_line *status) {
+        char *line;
+        switch (status->protocol) {
+        case PROTOCOL_ERROR:
                 return false;
-        }
-
-        if (bar->status->protocol == I3BAR) {
-                sway_log(L_DEBUG, "Sending click event.");
-
-                // find clicked block
-                struct status_block *clicked_block = NULL;
-                struct status_block *current_block = NULL;
-                int num_blocks = bar->status->block_line->length;
-
-                if (num_blocks == 0) {
-                        return false;
-                } else {
-                        current_block = bar->status->block_line->items[0];
-                        if (x < current_block->x) {
-                                return false;
-                        }
-                }
-
-                for (int i = 0; i < num_blocks; i++) {
-                        current_block = bar->status->block_line->items[i];
-                        if (x < (current_block->x + current_block->width)) {
-                                clicked_block = current_block;
-                                break;
-                        }
-                }
-
-                if (!clicked_block || !clicked_block->name) {
-                        return false;
-                }
-
-                // event example {"name":"capture","instance":"label","button":1,"x":3431,"y":18}
-        
-                struct json_object *event_json = json_object_new_object();
-                json_object_object_add(event_json, "name", json_object_new_string(clicked_block->name));
-                if (clicked_block->instance) {
-                        json_object_object_add(event_json, "instance", json_object_new_string(clicked_block->instance));
-                }
-                json_object_object_add(event_json, "button", json_object_new_int(button));
-                json_object_object_add(event_json, "x", json_object_new_int(x));
-                json_object_object_add(event_json, "y", json_object_new_int(y));
-
-                int len = snprintf(event_buff, sizeof(event_buff), "%s\n", json_object_to_json_string(event_json));
-
-                json_object_put(event_json);
-
-                if (len <= (int)sizeof(event_buff)) { // if not truncated
-                        write(bar->status_write_fd, event_buff, len);
+        case PROTOCOL_I3BAR:
+                if (i3bar_handle_readable(status) > 0) {
                         return true;
                 }
-        }
-
-        return false;
-}
-
-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;
+        case PROTOCOL_TEXT:
+                line = read_line_buffer(status->read,
+                                status->text_state.buffer, status->text_state.buffer_size);
+                if (!line) {
+                        status_error(status, "[error reading from status command]");
+                } else {
+                        status->text = line;
+                }
+                return true;
+        case PROTOCOL_UNDEF:
+                line = read_line_buffer(status->read,
+                                status->text_state.buffer, status->text_state.buffer_size);
+                if (!line) {
+                        status_error(status, "[error reading from status command]");
+                        return false;
                 }
-                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);
                         if (proto) {
-
                                 json_object *version;
                                 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;
+                                                        && json_object_get_int(version) == 1) {
+                                        wlr_log(L_DEBUG, "Switched to i3bar protocol.");
+                                        status->protocol = PROTOCOL_I3BAR;
                                 }
-
                                 json_object *click_events;
-                                if (json_object_object_get_ex(proto, "click_events", &click_events)
+                                if (json_object_object_get_ex(
+                                                        proto, "click_events", &click_events)
                                                 && json_object_get_boolean(click_events)) {
-
-                                        sway_log(L_DEBUG, "Enabling click events.");
-                                        bar->status->click_events = true;
-
+                                        wlr_log(L_DEBUG, "Enabled click events.");
+                                        status->i3bar_state.click_events = true;
                                         const char *events_array = "[\n";
-                                        write(bar->status_write_fd, events_array, strlen(events_array));
+                                        ssize_t len = strlen(events_array);
+                                        if (write(status->write_fd, events_array, len) != len) {
+                                                status_error(status,
+                                                                "[failed to write to status command]");
+                                        }
                                 }
-
-                                i3json_handle_data(bar, line_rest);
-
                                 json_object_put(proto);
                         }
+
+                        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);
+                } else {
+                        status->protocol = PROTOCOL_TEXT;
+                        status->text = line;
                 }
-                break;
+                return true;
         }
-
-        return dirty;
+        return false;
 }
 
-struct status_line *init_status_line() {
-        struct status_line *line = malloc(sizeof(struct status_line));
-        line->block_line = create_list();
-        line->text_line = NULL;
-        line->protocol = UNDEF;
-        line->click_events = false;
+struct status_line *status_line_init(char *cmd) {
+        struct status_line *status = calloc(1, sizeof(struct status_line));
+        status->text_state.buffer_size = 8192;
+        status->text_state.buffer = malloc(status->text_state.buffer_size);
 
-        return line;
-}
+        int pipe_read_fd[2];
+        int pipe_write_fd[2];
+        if (pipe(pipe_read_fd) != 0 || pipe(pipe_write_fd) != 0) {
+                wlr_log(L_ERROR, "Unable to create pipes for status_command fork");
+                exit(1);
+        }
+
+        status->pid = fork();
+        if (status->pid == 0) {
+                dup2(pipe_read_fd[1], STDOUT_FILENO);
+                close(pipe_read_fd[0]);
+                close(pipe_read_fd[1]);
 
-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);
+                dup2(pipe_write_fd[0], STDIN_FILENO);
+                close(pipe_write_fd[0]);
+                close(pipe_write_fd[1]);
+
+                char *const _cmd[] = { "sh", "-c", cmd, NULL, };
+                execvp(_cmd[0], _cmd);
+                exit(1);
         }
+
+        close(pipe_read_fd[1]);
+        status->read_fd = pipe_read_fd[0];
+        fcntl(status->read_fd, F_SETFL, O_NONBLOCK);
+        close(pipe_write_fd[0]);
+        status->write_fd = pipe_write_fd[1];
+        fcntl(status->write_fd, F_SETFL, O_NONBLOCK);
+
+        status->read = fdopen(status->read_fd, "r");
+        status->write = fdopen(status->write_fd, "w");
+        return status;
+}
+
+void status_line_free(struct status_line *status) {
+        close(status->read_fd);
+        close(status->write_fd);
+        kill(status->pid, SIGTERM);
+        free(status);
 }
diff --git a/swaybar/tray/dbus.c b/swaybar/tray/dbus.c
deleted file mode 100644
index 8e719fd9..00000000
--- a/swaybar/tray/dbus.c
+++ /dev/null
@@ -1,197 +0,0 @@
-#define _XOPEN_SOURCE 700
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <poll.h>
-#include <signal.h>
-#include <time.h>
-#include <dbus/dbus.h>
-#include "swaybar/tray/dbus.h"
-#include "swaybar/event_loop.h"
-#include "log.h"
-
-DBusConnection *conn = NULL;
-
-static void dispatch_watch(int fd, short mask, void *data) {
-        sway_log(L_DEBUG, "Dispatching watch");
-        DBusWatch *watch = data;
-
-        if (!dbus_watch_get_enabled(watch)) {
-                return;
-        }
-
-        uint32_t flags = 0;
-
-        if (mask & POLLIN) {
-                flags |= DBUS_WATCH_READABLE;
-        } if (mask & POLLOUT) {
-                flags |= DBUS_WATCH_WRITABLE;
-        } if (mask & POLLHUP) {
-                flags |= DBUS_WATCH_HANGUP;
-        } if (mask & POLLERR) {
-                flags |= DBUS_WATCH_ERROR;
-        }
-
-        dbus_watch_handle(watch, flags);
-}
-
-static dbus_bool_t add_watch(DBusWatch *watch, void *_data) {
-        if (!dbus_watch_get_enabled(watch)) {
-                // Watch should not be polled
-                return TRUE;
-        }
-
-        short mask = 0;
-        uint32_t flags = dbus_watch_get_flags(watch);
-
-        if (flags & DBUS_WATCH_READABLE) {
-                mask |= POLLIN;
-        } if (flags & DBUS_WATCH_WRITABLE) {
-                mask |= POLLOUT;
-        }
-
-        int fd = dbus_watch_get_unix_fd(watch);
-
-        sway_log(L_DEBUG, "Adding DBus watch fd: %d", fd);
-        add_event(fd, mask, dispatch_watch, watch);
-
-        return TRUE;
-}
-
-static void remove_watch(DBusWatch *watch, void *_data) {
-        int fd = dbus_watch_get_unix_fd(watch);
-
-        remove_event(fd);
-}
-
-static void dispatch_timeout(timer_t timer, void *data) {
-        sway_log(L_DEBUG, "Dispatching DBus timeout");
-        DBusTimeout *timeout = data;
-
-        if (dbus_timeout_get_enabled(timeout)) {
-                dbus_timeout_handle(timeout);
-        }
-}
-
-static dbus_bool_t add_timeout(DBusTimeout *timeout, void *_data) {
-        if (!dbus_timeout_get_enabled(timeout)) {
-                return TRUE;
-        }
-
-        timer_t *timer = malloc(sizeof(timer_t));
-        if (!timer) {
-                sway_log(L_ERROR, "Cannot allocate memory");
-                return FALSE;
-        }
-        struct sigevent ev = {
-                .sigev_notify = SIGEV_NONE,
-        };
-
-        if (timer_create(CLOCK_MONOTONIC, &ev, timer)) {
-                sway_log(L_ERROR, "Could not create DBus timer");
-                return FALSE;
-        }
-
-        int interval = dbus_timeout_get_interval(timeout);
-        int interval_sec = interval / 1000;
-        int interval_msec = (interval_sec * 1000) - interval;
-
-        struct timespec period = {
-                (time_t) interval_sec,
-                ((long) interval_msec) * 1000 * 1000,
-        };
-        struct itimerspec time = {
-                period,
-                period,
-        };
-
-        timer_settime(*timer, 0, &time, NULL);
-
-        dbus_timeout_set_data(timeout, timer, NULL);
-
-        sway_log(L_DEBUG, "Adding DBus timeout. Interval: %ds %dms", interval_sec, interval_msec);
-        add_timer(*timer, dispatch_timeout, timeout);
-
-        return TRUE;
-}
-static void remove_timeout(DBusTimeout *timeout, void *_data) {
-        timer_t *timer = (timer_t *) dbus_timeout_get_data(timeout);
-        sway_log(L_DEBUG, "Removing DBus timeout.");
-
-        if (timer) {
-                remove_timer(*timer);
-                timer_delete(*timer);
-                free(timer);
-        }
-}
-
-static bool should_dispatch = true;
-
-static void dispatch_status(DBusConnection *connection, DBusDispatchStatus new_status,
-                void *_data) {
-        if (new_status == DBUS_DISPATCH_DATA_REMAINS) {
-                should_dispatch = true;
-        }
-}
-
-/* Public functions below */
-
-void dispatch_dbus() {
-        if (!should_dispatch || !conn) {
-                return;
-        }
-
-        DBusDispatchStatus status;
-
-        do {
-                status = dbus_connection_dispatch(conn);
-        } while (status == DBUS_DISPATCH_DATA_REMAINS);
-
-        if (status != DBUS_DISPATCH_COMPLETE) {
-                sway_log(L_ERROR, "Cannot dispatch dbus events: %d", status);
-        }
-
-        should_dispatch = false;
-}
-
-int dbus_init() {
-        DBusError error;
-        dbus_error_init(&error);
-
-        conn = dbus_bus_get(DBUS_BUS_SESSION, &error);
-        if (conn == NULL) {
-                sway_log(L_INFO, "Compiled with dbus support, but unable to connect to dbus");
-                sway_log(L_INFO, "swaybar will be unable to display tray icons.");
-                return -1;
-        }
-
-        dbus_connection_set_exit_on_disconnect(conn, FALSE);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "Cannot get bus connection: %s\n", error.message);
-                conn = NULL;
-                return -1;
-        }
-
-        sway_log(L_INFO, "Unique name: %s\n", dbus_bus_get_unique_name(conn));
-
-        // Will be called if dispatch status changes
-        dbus_connection_set_dispatch_status_function(conn, dispatch_status, NULL, NULL);
-
-        if (!dbus_connection_set_watch_functions(conn, add_watch, remove_watch,
-                        NULL, NULL, NULL)) {
-                dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL);
-                sway_log(L_ERROR, "Failed to activate DBUS watch functions");
-                return -1;
-        }
-
-        if (!dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout,
-                        NULL, NULL, NULL)) {
-                dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL);
-                dbus_connection_set_timeout_functions(conn, NULL, NULL, NULL, NULL, NULL);
-                sway_log(L_ERROR, "Failed to activate DBUS timeout functions");
-                return -1;
-        }
-
-        return 0;
-}
diff --git a/swaybar/tray/icon.c b/swaybar/tray/icon.c
deleted file mode 100644
index c146bf32..00000000
--- a/swaybar/tray/icon.c
+++ /dev/null
@@ -1,400 +0,0 @@
-#define _XOPEN_SOURCE 700
-#define _POSIX_C_SOURCE 200809L
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <limits.h>
-#include "swaybar/tray/icon.h"
-#include "swaybar/bar.h"
-#include "swaybar/config.h"
-#include "stringop.h"
-#include "log.h"
-
-/**
- * REVIEW:
- * This file repeats lots of "costly" operations that are the same for every
- * icon. It's possible to create a dictionary or some other structure to cache
- * these, though it may complicate things somewhat.
- *
- * Also parsing (index.theme) is currently pretty messy, so that could be made
- * much better as well. Over all, things work, but are not optimal.
- */
-
-/* Finds all themes that the given theme inherits */
-static list_t *find_inherits(const char *theme_dir) {
-        const char inherits[] = "Inherits";
-        const char index_name[] = "index.theme";
-        list_t *themes = create_list();
-        FILE *index = NULL;
-        char *path = malloc(strlen(theme_dir) + sizeof(index_name));
-        if (!path) {
-                goto fail;
-        }
-        if (!themes) {
-                goto fail;
-        }
-
-        strcpy(path, theme_dir);
-        strcat(path, index_name);
-
-        index = fopen(path, "r");
-        if (!index) {
-                goto fail;
-        }
-
-        char *buf = NULL;
-        size_t n = 0;
-        while (!feof(index) && getline(&buf, &n, index) != -1) {
-                if (n <= sizeof(inherits) + 1) {
-                        continue;
-                }
-                if (strncmp(inherits, buf, sizeof(inherits) - 1) == 0) {
-                        char *themestr = buf + sizeof(inherits);
-                        themes = split_string(themestr, ",");
-                        break;
-                }
-        }
-        free(buf);
-
-fail:
-        free(path);
-        if (index) {
-                fclose(index);
-        }
-        return themes;
-}
-
-static bool isdir(const char *path) {
-        struct stat statbuf;
-        if (stat(path, &statbuf) != -1) {
-                if (S_ISDIR(statbuf.st_mode)) {
-                        return true;
-                }
-        }
-        return false;
-
-}
-
-/**
- * Returns the directory of a given theme if it exists.
- * The returned pointer must be freed.
- */
-static char *find_theme_dir(const char *theme) {
-        char *basedir;
-        char *icon_dir;
-
-        if (!theme) {
-                return NULL;
-        }
-
-        if (!(icon_dir = malloc(1024))) {
-                sway_log(L_ERROR, "Out of memory!");
-                goto fail;
-        }
-
-        if ((basedir = getenv("HOME"))) {
-                if (snprintf(icon_dir, 1024, "%s/.icons/%s", basedir, theme) >= 1024) {
-                        sway_log(L_ERROR, "Path too long to render");
-                        // XXX perhaps just goto trying in /usr/share? This
-                        // shouldn't happen anyway, but might with a long global
-                        goto fail;
-                }
-
-                if (isdir(icon_dir)) {
-                        return icon_dir;
-                }
-        }
-
-        if ((basedir = getenv("XDG_DATA_DIRS"))) {
-                if (snprintf(icon_dir, 1024, "%s/icons/%s", basedir, theme) >= 1024) {
-                        sway_log(L_ERROR, "Path too long to render");
-                        // ditto
-                        goto fail;
-                }
-
-                if (isdir(icon_dir)) {
-                        return icon_dir;
-                }
-        }
-
-        // Spec says use "/usr/share/pixmaps/", but I see everything in
-        // "/usr/share/icons/" look it both, I suppose.
-        if (snprintf(icon_dir, 1024, "/usr/share/pixmaps/%s", theme) >= 1024) {
-                sway_log(L_ERROR, "Path too long to render");
-                goto fail;
-        }
-        if (isdir(icon_dir)) {
-                return icon_dir;
-        }
-
-        if (snprintf(icon_dir, 1024, "/usr/share/icons/%s", theme) >= 1024) {
-                sway_log(L_ERROR, "Path too long to render");
-                goto fail;
-        }
-        if (isdir(icon_dir)) {
-                return icon_dir;
-        }
-
-fail:
-        free(icon_dir);
-        sway_log(L_ERROR, "Could not find dir for theme: %s", theme);
-        return NULL;
-}
-
-/**
- * Returns all theme dirs needed to be looked in for an icon.
- * Does not check for duplicates
- */
-static list_t *find_all_theme_dirs(const char *theme) {
-        list_t *dirs = create_list();
-        if (!dirs) {
-                return NULL;
-        }
-        char *dir = find_theme_dir(theme);
-        if (dir) {
-                list_add(dirs, dir);
-                list_t *inherits = find_inherits(dir);
-                list_cat(dirs, inherits);
-                list_free(inherits);
-        }
-        dir = find_theme_dir("hicolor");
-        if (dir) {
-                list_add(dirs, dir);
-        }
-
-        return dirs;
-}
-
-struct subdir {
-        int size;
-        char name[];
-};
-
-static int subdir_str_cmp(const void *_subdir, const void *_str) {
-        const struct subdir *subdir = _subdir;
-        const char *str = _str;
-        return strcmp(subdir->name, str);
-}
-/**
- * Helper to find_subdirs. Acts similar to `split_string(subdirs, ",")` but
- * generates a list of struct subdirs
- */
-static list_t *split_subdirs(char *subdir_str) {
-        list_t *subdir_list = create_list();
-        char *copy = strdup(subdir_str);
-        if (!subdir_list || !copy) {
-                list_free(subdir_list);
-                free(copy);
-                return NULL;
-        }
-
-        char *token;
-        token = strtok(copy, ",");
-        while(token) {
-                int len = strlen(token) + 1;
-                struct subdir *subdir =
-                        malloc(sizeof(struct subdir) + sizeof(char [len]));
-                if (!subdir) {
-                        // Return what we have
-                        return subdir_list;
-                }
-                subdir->size = 0;
-                strcpy(subdir->name, token);
-
-                list_add(subdir_list, subdir);
-
-                token = strtok(NULL, ",");
-        }
-        free(copy);
-
-        return subdir_list;
-}
-/**
- * Returns a list of all subdirectories of a theme.
- * Take note: the subdir names are all relative to `theme_dir` and must be
- * combined with it to form a valid directory.
- *
- * Each member of the list is of type (struct subdir *) this struct contains
- * the name of the subdir, along with size information. These must be freed
- * bye the caller.
- *
- * This currently ignores min and max sizes of icons.
- */
-static list_t* find_theme_subdirs(const char *theme_dir) {
-        const char index_name[] = "/index.theme";
-        list_t *dirs = NULL;
-        char *path = malloc(strlen(theme_dir) + sizeof(index_name));
-        FILE *index = NULL;
-        if (!path) {
-                sway_log(L_ERROR, "Failed to allocate memory");
-                goto fail;
-        }
-
-        strcpy(path, theme_dir);
-        strcat(path, index_name);
-
-        index = fopen(path, "r");
-        if (!index) {
-                sway_log(L_ERROR, "Could not open file: %s", path);
-                goto fail;
-        }
-
-        char *buf = NULL;
-        size_t n = 0;
-        const char directories[] = "Directories";
-        while (!feof(index) && getline(&buf, &n, index) != -1) {
-                if (n <= sizeof(directories) + 1) {
-                        continue;
-                }
-                if (strncmp(directories, buf, sizeof(directories) - 1) == 0) {
-                        char *dirstr = buf + sizeof(directories);
-                        dirs = split_subdirs(dirstr);
-                        break;
-                }
-        }
-        // Now, find the size of each dir
-        struct subdir *current_subdir = NULL;
-        const char size[] = "Size";
-        while (!feof(index) && getline(&buf, &n, index) != -1) {
-                if (buf[0] == '[') {
-                        int len = strlen(buf);
-                        if (buf[len-1] == '\n') {
-                                len--;
-                        }
-                        // replace ']'
-                        buf[len-1] = '\0';
-
-                        int index;
-                        if ((index = list_seq_find(dirs, subdir_str_cmp, buf+1)) != -1) {
-                                current_subdir = (dirs->items[index]);
-                        }
-                }
-
-                if (strncmp(size, buf, sizeof(size) - 1) == 0) {
-                        if (current_subdir) {
-                                current_subdir->size = atoi(buf + sizeof(size));
-                        }
-                }
-        }
-        free(buf);
-fail:
-        free(path);
-        if (index) {
-                fclose(index);
-        }
-        return dirs;
-}
-
-/* Returns the file of an icon given its name and size */
-static char *find_icon_file(const char *name, int size) {
-        int namelen = strlen(name);
-        list_t *dirs = find_all_theme_dirs(swaybar.config->icon_theme);
-        if (!dirs) {
-                return NULL;
-        }
-        int min_size_diff = INT_MAX;
-        char *current_file = NULL;
-
-        for (int i = 0; i < dirs->length; ++i) {
-                char *dir = dirs->items[i];
-                list_t *subdirs = find_theme_subdirs(dir);
-
-                if (!subdirs) {
-                        continue;
-                }
-
-                for (int i = 0; i < subdirs->length; ++i) {
-                        struct subdir *subdir = subdirs->items[i];
-
-                        // Only use an unsized if we don't already have a
-                        // canidate this should probably change to allow svgs
-                        if (!subdir->size && current_file) {
-                                continue;
-                        }
-
-                        int size_diff = abs(size - subdir->size);
-
-                        if (size_diff >= min_size_diff) {
-                                continue;
-                        }
-
-                        char *path = malloc(strlen(subdir->name) + strlen(dir) + 2);
-
-                        strcpy(path, dir);
-                        path[strlen(dir)] = '/';
-                        strcpy(path + strlen(dir) + 1, subdir->name);
-
-                        DIR *icons = opendir(path);
-                        if (!icons) {
-                                free(path);
-                                continue;
-                        }
-
-                        struct dirent *direntry;
-                        while ((direntry = readdir(icons)) != NULL) {
-                                int len = strlen(direntry->d_name);
-                                if (len <= namelen + 2) { //must have some ext
-                                        continue;
-                                }
-                                if (strncmp(direntry->d_name, name, namelen) == 0) {
-                                        char *ext = direntry->d_name + namelen + 1;
-#ifdef WITH_GDK_PIXBUF
-                                        if (strcmp(ext, "png") == 0 ||
-                                                        strcmp(ext, "xpm") == 0 ||
-                                                        strcmp(ext, "svg") == 0) {
-#else
-                                        if (strcmp(ext, "png") == 0) {
-#endif
-                                                free(current_file);
-                                                char *icon_path = malloc(strlen(path) + len + 2);
-
-                                                strcpy(icon_path, path);
-                                                icon_path[strlen(path)] = '/';
-                                                strcpy(icon_path + strlen(path) + 1, direntry->d_name);
-                                                current_file = icon_path;
-                                                min_size_diff = size_diff;
-                                        }
-                                }
-                        }
-                        free(path);
-                        closedir(icons);
-                }
-                free_flat_list(subdirs);
-        }
-        free_flat_list(dirs);
-
-        return current_file;
-}
-
-cairo_surface_t *find_icon(const char *name, int size) {
-        char *image_path = find_icon_file(name, size);
-        if (image_path == NULL) {
-                return NULL;
-        }
-
-        cairo_surface_t *image = NULL;
-#ifdef WITH_GDK_PIXBUF
-        GError *err = NULL;
-        GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(image_path, &err);
-        if (!pixbuf) {
-                sway_log(L_ERROR, "Failed to load icon image: %s", err->message);
-        }
-        image = gdk_cairo_image_surface_create_from_pixbuf(pixbuf);
-        g_object_unref(pixbuf);
-#else
-        // TODO make svg work? cairo supports it. maybe remove gdk alltogether
-        image = cairo_image_surface_create_from_png(image_path);
-#endif //WITH_GDK_PIXBUF
-        if (!image) {
-                sway_log(L_ERROR, "Could not read icon image");
-                return NULL;
-        }
-
-        free(image_path);
-        return image;
-}
diff --git a/swaybar/tray/sni.c b/swaybar/tray/sni.c
deleted file mode 100644
index c9d00657..00000000
--- a/swaybar/tray/sni.c
+++ /dev/null
@@ -1,481 +0,0 @@
-#define _XOPEN_SOURCE 500
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <dbus/dbus.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include "swaybar/tray/dbus.h"
-#include "swaybar/tray/sni.h"
-#include "swaybar/tray/icon.h"
-#include "swaybar/bar.h"
-#include "client/cairo.h"
-#include "log.h"
-
-// Not sure what this is but cairo needs it.
-static const cairo_user_data_key_t cairo_user_data_key;
-
-struct sni_icon_ref *sni_icon_ref_create(struct StatusNotifierItem *item,
-                int height) {
-        struct sni_icon_ref *sni_ref = malloc(sizeof(struct sni_icon_ref));
-        if (!sni_ref) {
-                return NULL;
-        }
-        sni_ref->icon = cairo_image_surface_scale(item->image, height, height);
-        sni_ref->ref = item;
-
-        return sni_ref;
-}
-
-void sni_icon_ref_free(struct sni_icon_ref *sni_ref) {
-        if (!sni_ref) {
-                return;
-        }
-        cairo_surface_destroy(sni_ref->icon);
-        free(sni_ref);
-}
-
-/* Gets the pixmap of an icon */
-static void reply_icon(DBusPendingCall *pending, void *_data) {
-        struct StatusNotifierItem *item = _data;
-
-        DBusMessage *reply = dbus_pending_call_steal_reply(pending);
-
-        if (!reply) {
-                sway_log(L_ERROR, "Did not get reply");
-                goto bail;
-        }
-
-        int message_type = dbus_message_get_type(reply);
-
-        if (message_type == DBUS_MESSAGE_TYPE_ERROR) {
-                char *msg;
-
-                dbus_message_get_args(reply, NULL,
-                                DBUS_TYPE_STRING, &msg,
-                                DBUS_TYPE_INVALID);
-
-                sway_log(L_ERROR, "Message is error: %s", msg);
-                goto bail;
-        }
-
-        DBusMessageIter iter;
-        DBusMessageIter variant; /* v[a(iiay)] */
-        DBusMessageIter array; /* a(iiay) */
-        DBusMessageIter d_struct; /* (iiay) */
-        DBusMessageIter icon; /* ay */
-
-        dbus_message_iter_init(reply, &iter);
-
-        // Each if here checks the types above before recursing
-        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                sway_log(L_ERROR, "Relpy type incorrect");
-                sway_log(L_ERROR, "Should be \"v\", is \"%s\"",
-                                dbus_message_iter_get_signature(&iter));
-                goto bail;
-        }
-        dbus_message_iter_recurse(&iter, &variant);
-
-        if (strcmp("a(iiay)", dbus_message_iter_get_signature(&variant)) != 0) {
-                sway_log(L_ERROR, "Relpy type incorrect");
-                sway_log(L_ERROR, "Should be \"a(iiay)\", is \"%s\"",
-                                dbus_message_iter_get_signature(&variant));
-                goto bail;
-        }
-
-        if (dbus_message_iter_get_element_count(&variant) == 0) {
-                // Can't recurse if there are no items
-                sway_log(L_INFO, "Item has no icon");
-                goto bail;
-        }
-        dbus_message_iter_recurse(&variant, &array);
-
-        dbus_message_iter_recurse(&array, &d_struct);
-
-        int width;
-        dbus_message_iter_get_basic(&d_struct, &width);
-        dbus_message_iter_next(&d_struct);
-
-        int height;
-        dbus_message_iter_get_basic(&d_struct, &height);
-        dbus_message_iter_next(&d_struct);
-
-        int len = dbus_message_iter_get_element_count(&d_struct);
-
-        if (!len) {
-                sway_log(L_ERROR, "No icon data");
-                goto bail;
-        }
-
-        // Also implies len % 4 == 0, useful below
-        if (len != width * height * 4) {
-                sway_log(L_ERROR, "Incorrect array size passed");
-                goto bail;
-        }
-
-        dbus_message_iter_recurse(&d_struct, &icon);
-
-        int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
-        // FIXME support a variable stride
-        // (works on my machine though for all tested widths)
-        if (!sway_assert(stride == width * 4, "Stride must be equal to byte length")) {
-                goto bail;
-        }
-
-        // Data is by reference, no need to free
-        uint8_t *message_data;
-        dbus_message_iter_get_fixed_array(&icon, &message_data, &len);
-
-        uint8_t *image_data = malloc(stride * height);
-        if (!image_data) {
-                sway_log(L_ERROR, "Could not allocate memory for icon");
-                goto bail;
-        }
-
-        // Transform from network byte order to host byte order
-        // Assumptions are safe because the equality above
-        uint32_t *network = (uint32_t *) message_data;
-        uint32_t *host = (uint32_t *)image_data;
-        for (int i = 0; i < width * height; ++i) {
-                host[i] = ntohl(network[i]);
-        }
-
-        cairo_surface_t *image = cairo_image_surface_create_for_data(
-                        image_data, CAIRO_FORMAT_ARGB32,
-                        width, height, stride);
-
-        if (image) {
-                if (item->image) {
-                        cairo_surface_destroy(item->image);
-                }
-                item->image = image;
-                // Free the image data on surface destruction
-                cairo_surface_set_user_data(image,
-                                &cairo_user_data_key,
-                                image_data,
-                                free);
-                item->dirty = true;
-                dirty = true;
-
-                dbus_message_unref(reply);
-                dbus_pending_call_unref(pending);
-                return;
-        } else {
-                sway_log(L_ERROR, "Could not create image surface");
-                free(image_data);
-        }
-
-bail:
-        if (reply) {
-                dbus_message_unref(reply);
-        }
-        dbus_pending_call_unref(pending);
-        sway_log(L_ERROR, "Could not get icon from item");
-        return;
-}
-static void send_icon_msg(struct StatusNotifierItem *item) {
-        DBusPendingCall *pending;
-        DBusMessage *message = dbus_message_new_method_call(
-                        item->name,
-                        "/StatusNotifierItem",
-                        "org.freedesktop.DBus.Properties",
-                        "Get");
-        const char *iface;
-        if (item->kde_special_snowflake) {
-                iface = "org.kde.StatusNotifierItem";
-        } else {
-                iface = "org.freedesktop.StatusNotifierItem";
-        }
-        const char *prop = "IconPixmap";
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_STRING, &iface,
-                        DBUS_TYPE_STRING, &prop,
-                        DBUS_TYPE_INVALID);
-
-        bool status =
-                dbus_connection_send_with_reply(conn, message, &pending, -1);
-
-        dbus_message_unref(message);
-
-        if (!(pending || status)) {
-                sway_log(L_ERROR, "Could not get item icon");
-                return;
-        }
-
-        dbus_pending_call_set_notify(pending, reply_icon, item, NULL);
-}
-
-/* Get an icon by its name */
-static void reply_icon_name(DBusPendingCall *pending, void *_data) {
-        struct StatusNotifierItem *item = _data;
-
-        DBusMessage *reply = dbus_pending_call_steal_reply(pending);
-
-        if (!reply) {
-                sway_log(L_INFO, "Got no icon name reply from item");
-                goto bail;
-        }
-
-        int message_type = dbus_message_get_type(reply);
-
-        if (message_type == DBUS_MESSAGE_TYPE_ERROR) {
-                char *msg;
-
-                dbus_message_get_args(reply, NULL,
-                                DBUS_TYPE_STRING, &msg,
-                                DBUS_TYPE_INVALID);
-
-                sway_log(L_INFO, "Could not get icon name: %s", msg);
-                goto bail;
-        }
-
-        DBusMessageIter iter; /* v[s] */
-        DBusMessageIter variant; /* s */
-
-        dbus_message_iter_init(reply, &iter);
-        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                sway_log(L_ERROR, "Relpy type incorrect");
-                sway_log(L_ERROR, "Should be \"v\", is \"%s\"",
-                                dbus_message_iter_get_signature(&iter));
-                goto bail;
-        }
-        dbus_message_iter_recurse(&iter, &variant);
-
-
-        if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_STRING) {
-                sway_log(L_ERROR, "Relpy type incorrect");
-                sway_log(L_ERROR, "Should be \"s\", is \"%s\"",
-                                dbus_message_iter_get_signature(&iter));
-                goto bail;
-        }
-
-        char *icon_name;
-        dbus_message_iter_get_basic(&variant, &icon_name);
-
-        cairo_surface_t *image = find_icon(icon_name, 256);
-
-        if (image) {
-                sway_log(L_DEBUG, "Icon for %s found with size %d", icon_name,
-                                cairo_image_surface_get_width(image));
-                if (item->image) {
-                        cairo_surface_destroy(item->image);
-                }
-                item->image = image;
-                item->dirty = true;
-                dirty = true;
-
-                dbus_message_unref(reply);
-                dbus_pending_call_unref(pending);
-                return;
-        }
-
-bail:
-        if (reply) {
-                dbus_message_unref(reply);
-        }
-        dbus_pending_call_unref(pending);
-        // Now try the pixmap
-        send_icon_msg(item);
-        return;
-}
-static void send_icon_name_msg(struct StatusNotifierItem *item) {
-        DBusPendingCall *pending;
-        DBusMessage *message = dbus_message_new_method_call(
-                        item->name,
-                        "/StatusNotifierItem",
-                        "org.freedesktop.DBus.Properties",
-                        "Get");
-        const char *iface;
-        if (item->kde_special_snowflake) {
-                iface = "org.kde.StatusNotifierItem";
-        } else {
-                iface = "org.freedesktop.StatusNotifierItem";
-        }
-        const char *prop = "IconName";
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_STRING, &iface,
-                        DBUS_TYPE_STRING, &prop,
-                        DBUS_TYPE_INVALID);
-
-        bool status =
-                dbus_connection_send_with_reply(conn, message, &pending, -1);
-
-        dbus_message_unref(message);
-
-        if (!(pending || status)) {
-                sway_log(L_ERROR, "Could not get item icon name");
-                return;
-        }
-
-        dbus_pending_call_set_notify(pending, reply_icon_name, item, NULL);
-}
-
-void get_icon(struct StatusNotifierItem *item) {
-        send_icon_name_msg(item);
-}
-
-void sni_activate(struct StatusNotifierItem *item, uint32_t x, uint32_t y) {
-        const char *iface =
-                (item->kde_special_snowflake ? "org.kde.StatusNotifierItem"
-                 : "org.freedesktop.StatusNotifierItem");
-        DBusMessage *message = dbus_message_new_method_call(
-                        item->name,
-                        "/StatusNotifierItem",
-                        iface,
-                        "Activate");
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_INT32, &x,
-                        DBUS_TYPE_INT32, &y,
-                        DBUS_TYPE_INVALID);
-
-        dbus_connection_send(conn, message, NULL);
-
-        dbus_message_unref(message);
-}
-
-void sni_context_menu(struct StatusNotifierItem *item, uint32_t x, uint32_t y) {
-        const char *iface =
-                (item->kde_special_snowflake ? "org.kde.StatusNotifierItem"
-                 : "org.freedesktop.StatusNotifierItem");
-        DBusMessage *message = dbus_message_new_method_call(
-                        item->name,
-                        "/StatusNotifierItem",
-                        iface,
-                        "ContextMenu");
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_INT32, &x,
-                        DBUS_TYPE_INT32, &y,
-                        DBUS_TYPE_INVALID);
-
-        dbus_connection_send(conn, message, NULL);
-
-        dbus_message_unref(message);
-}
-void sni_secondary(struct StatusNotifierItem *item, uint32_t x, uint32_t y) {
-        const char *iface =
-                (item->kde_special_snowflake ? "org.kde.StatusNotifierItem"
-                 : "org.freedesktop.StatusNotifierItem");
-        DBusMessage *message = dbus_message_new_method_call(
-                        item->name,
-                        "/StatusNotifierItem",
-                        iface,
-                        "SecondaryActivate");
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_INT32, &x,
-                        DBUS_TYPE_INT32, &y,
-                        DBUS_TYPE_INVALID);
-
-        dbus_connection_send(conn, message, NULL);
-
-        dbus_message_unref(message);
-}
-
-static void get_unique_name(struct StatusNotifierItem *item) {
-        // I think that we're fine being sync here becaues the message is
-        // directly to the message bus. Could be async though.
-        DBusMessage *message = dbus_message_new_method_call(
-                        "org.freedesktop.DBus",
-                        "/org/freedesktop/DBus",
-                        "org.freedesktop.DBus",
-                        "GetNameOwner");
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_STRING, &item->name,
-                        DBUS_TYPE_INVALID);
-
-        DBusMessage *reply = dbus_connection_send_with_reply_and_block(
-                        conn, message, -1, NULL);
-
-        dbus_message_unref(message);
-
-        if (!reply) {
-                sway_log(L_ERROR, "Could not get unique name for item: %s",
-                                item->name);
-                return;
-        }
-
-        char *unique_name;
-        if (!dbus_message_get_args(reply, NULL,
-                                DBUS_TYPE_STRING, &unique_name,
-                                DBUS_TYPE_INVALID)) {
-                sway_log(L_ERROR, "Error parsing method args");
-        } else {
-                if (item->unique_name) {
-                        free(item->unique_name);
-                }
-                item->unique_name = strdup(unique_name);
-        }
-
-        dbus_message_unref(reply);
-}
-
-struct StatusNotifierItem *sni_create(const char *name) {
-        // Make sure `name` is well formed
-        if (!dbus_validate_bus_name(name, NULL)) {
-                sway_log(L_INFO, "Name (%s) is not a bus name. We cannot create an item.", name);
-                return NULL;
-        }
-
-        struct StatusNotifierItem *item = malloc(sizeof(struct StatusNotifierItem));
-        item->name = strdup(name);
-        item->unique_name = NULL;
-        item->image = NULL;
-        item->dirty = false;
-
-        // If it doesn't use this name then assume that it uses the KDE spec
-        // This is because xembed-sni-proxy uses neither "org.freedesktop" nor
-        // "org.kde" and just gives us the items "unique name"
-        //
-        // We could use this to our advantage and fill out the "unique name"
-        // field with the given name if it is neither freedesktop or kde, but
-        // that's makes us rely on KDE hackyness which is bad practice
-        const char freedesktop_name[] = "org.freedesktop";
-        if (strncmp(name, freedesktop_name, sizeof(freedesktop_name) - 1) != 0) {
-                item->kde_special_snowflake = true;
-        } else {
-                item->kde_special_snowflake = false;
-        }
-
-        get_icon(item);
-
-        get_unique_name(item);
-
-        return item;
-}
-/* Return 0 if `item` has a name of `str` */
-int sni_str_cmp(const void *_item, const void *_str) {
-        const struct StatusNotifierItem *item = _item;
-        const char *str = _str;
-
-        return strcmp(item->name, str);
-}
-/* Returns 0 if `item` has a unique name of `str` */
-int sni_uniq_cmp(const void *_item, const void *_str) {
-        const struct StatusNotifierItem *item = _item;
-        const char *str = _str;
-
-        if (!item->unique_name) {
-                return false;
-        }
-        return strcmp(item->unique_name, str);
-}
-void sni_free(struct StatusNotifierItem *item) {
-        if (!item) {
-                return;
-        }
-        free(item->name);
-        if (item->unique_name) {
-                free(item->unique_name);
-        }
-        if (item->image) {
-                cairo_surface_destroy(item->image);
-        }
-        free(item);
-}
diff --git a/swaybar/tray/sni_watcher.c b/swaybar/tray/sni_watcher.c
deleted file mode 100644
index 86453e70..00000000
--- a/swaybar/tray/sni_watcher.c
+++ /dev/null
@@ -1,497 +0,0 @@
-#define _XOPEN_SOURCE 500
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <dbus/dbus.h>
-#include "swaybar/tray/dbus.h"
-#include "list.h"
-#include "log.h"
-
-static list_t *items = NULL;
-static list_t *hosts = NULL;
-
-/**
- * Describes the function of the StatusNotifierWatcher
- * See https://freedesktop.org/wiki/Specifications/StatusNotifierItem/StatusNotifierWatcher/
- *
- * We also implement KDE's special snowflake protocol, it's like this but with
- * all occurrences 'freedesktop' replaced with 'kde'. There is no KDE introspect.
- */
-static const char *interface_xml =
-        "<!DOCTYPE node PUBLIC '-//freedesktop//DTD D-BUS Object Introspection 1.0//EN'"
-        "'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>"
-        "<node>"
-        "  <interface name='org.freedesktop.DBus.Introspectable'>"
-        "    <method name='Introspect'>"
-        "       <arg name='xml_data' direction='out' type='s'/>"
-        "    </method>"
-        "  </interface>"
-        "  <interface name='org.freedesktop.DBus.Properties'>"
-        "    <method name='Get'>"
-        "       <arg name='interface' direction='in' type='s'/>"
-        "       <arg name='propname' direction='in' type='s'/>"
-        "       <arg name='value' direction='out' type='v'/>"
-        "    </method>"
-        "    <method name='Set'>"
-        "       <arg name='interface' direction='in' type='s'/>"
-        "       <arg name='propname' direction='in' type='s'/>"
-        "       <arg name='value' direction='in' type='v'/>"
-        "    </method>"
-        "    <method name='GetAll'>"
-        "       <arg name='interface' direction='in' type='s'/>"
-        "       <arg name='props' direction='out' type='a{sv}'/>"
-        "    </method>"
-        "  </interface>"
-        "  <interface name='org.freedesktop.StatusNotifierWatcher'>"
-        "    <method name='RegisterStatusNotifierItem'>"
-        "      <arg type='s' name='service' direction='in'/>"
-        "    </method>"
-        "    <method name='RegisterStatusNotifierHost'>"
-        "      <arg type='s' name='service' direction='in'/>"
-        "    </method>"
-        "    <property name='RegisteredStatusNotifierItems' type='as' access='read'/>"
-        "    <property name='IsStatusNotifierHostRegistered' type='b' access='read'/>"
-        "    <property name='ProtocolVersion' type='i' access='read'/>"
-        "    <signal name='StatusNotifierItemRegistered'>"
-        "      <arg type='s' name='service' direction='out'/>"
-        "    </signal>"
-        "    <signal name='StatusNotifierItemUnregistered'>"
-        "      <arg type='s' name='service' direction='out'/>"
-        "    </signal>"
-        "    <signal name='StatusNotifierHostRegistered'>"
-        "      <arg type='' name='service' direction='out'/>"
-        "    </signal>"
-        "  </interface>"
-        "</node>";
-
-static void host_registered_signal(DBusConnection *connection) {
-        // Send one signal for each protocol
-        DBusMessage *signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "StatusNotifierHostRegistered");
-
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-
-
-        signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.kde.StatusNotifierWatcher",
-                        "StatusNotifierHostRegistered");
-
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-}
-static void item_registered_signal(DBusConnection *connection, const char *name) {
-        DBusMessage *signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "StatusNotifierItemRegistered");
-        dbus_message_append_args(signal,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_INVALID);
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-
-        signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.kde.StatusNotifierWatcher",
-                        "StatusNotifierItemRegistered");
-        dbus_message_append_args(signal,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_INVALID);
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-}
-static void item_unregistered_signal(DBusConnection *connection, const char *name) {
-        DBusMessage *signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "StatusNotifierItemUnregistered");
-        dbus_message_append_args(signal,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_INVALID);
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-
-        signal = dbus_message_new_signal(
-                        "/StatusNotifierWatcher",
-                        "org.kde.StatusNotifierWatcher",
-                        "StatusNotifierItemUnregistered");
-        dbus_message_append_args(signal,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_INVALID);
-        dbus_connection_send(connection, signal, NULL);
-        dbus_message_unref(signal);
-}
-
-static void respond_to_introspect(DBusConnection *connection, DBusMessage *request) {
-        DBusMessage *reply;
-
-        reply = dbus_message_new_method_return(request);
-        dbus_message_append_args(reply,
-                        DBUS_TYPE_STRING, &interface_xml,
-                        DBUS_TYPE_INVALID);
-        dbus_connection_send(connection, reply, NULL);
-        dbus_message_unref(reply);
-}
-
-static void register_item(DBusConnection *connection, DBusMessage *message) {
-        DBusError error;
-        char *name;
-
-        dbus_error_init(&error);
-        if (!dbus_message_get_args(message, &error,
-                                DBUS_TYPE_STRING, &name,
-                                DBUS_TYPE_INVALID)) {
-                sway_log(L_ERROR, "Error parsing method args: %s\n", error.message);
-        }
-
-        sway_log(L_INFO, "RegisterStatusNotifierItem called with \"%s\"\n", name);
-
-        // Don't add duplicate or not real item
-        if (!dbus_validate_bus_name(name, NULL)) {
-                sway_log(L_INFO, "This item is not valid, we cannot keep track of it.");
-                return;
-        }
-
-        if (list_seq_find(items, (int (*)(const void *, const void *))strcmp, name) != -1) {
-                return;
-        }
-        if (!dbus_bus_name_has_owner(connection, name, &error)) {
-                return;
-        }
-
-        list_add(items, strdup(name));
-        item_registered_signal(connection, name);
-
-        // It's silly, but xembedsniproxy wants a reply for this function
-        DBusMessage *reply = dbus_message_new_method_return(message);
-        dbus_connection_send(connection, reply, NULL);
-        dbus_message_unref(reply);
-}
-
-static void register_host(DBusConnection *connection, DBusMessage *message) {
-        DBusError error;
-        char *name;
-
-        dbus_error_init(&error);
-        if (!dbus_message_get_args(message, &error,
-                                DBUS_TYPE_STRING, &name,
-                                DBUS_TYPE_INVALID)) {
-                sway_log(L_ERROR, "Error parsing method args: %s\n", error.message);
-        }
-
-        sway_log(L_INFO, "RegisterStatusNotifierHost called with \"%s\"\n", name);
-
-        // Don't add duplicate or not real host
-        if (!dbus_validate_bus_name(name, NULL)) {
-                sway_log(L_INFO, "This item is not valid, we cannot keep track of it.");
-                return;
-        }
-
-
-        if (list_seq_find(hosts, (int (*)(const void *, const void *))strcmp, name) != -1) {
-                return;
-        }
-        if (!dbus_bus_name_has_owner(connection, name, &error)) {
-                return;
-        }
-
-        list_add(hosts, strdup(name));
-        host_registered_signal(connection);
-}
-
-static void get_property(DBusConnection *connection, DBusMessage *message) {
-        DBusError error;
-        char *interface;
-        char *property;
-
-        dbus_error_init(&error);
-        if (!dbus_message_get_args(message, &error,
-                                DBUS_TYPE_STRING, &interface,
-                                DBUS_TYPE_STRING, &property,
-                                DBUS_TYPE_INVALID)) {
-                sway_log(L_ERROR, "Error parsing prop args: %s\n", error.message);
-                return;
-        }
-
-        if (strcmp(property, "RegisteredStatusNotifierItems") == 0) {
-                sway_log(L_INFO, "Replying with items\n");
-                DBusMessage *reply;
-                reply = dbus_message_new_method_return(message);
-                DBusMessageIter iter;
-                DBusMessageIter sub;
-                DBusMessageIter subsub;
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
-                                "as", &sub);
-                dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY,
-                                "s", &subsub);
-
-                for (int i = 0; i < items->length; ++i) {
-                        dbus_message_iter_append_basic(&subsub,
-                                        DBUS_TYPE_STRING, &items->items[i]);
-                }
-
-                dbus_message_iter_close_container(&sub, &subsub);
-                dbus_message_iter_close_container(&iter, &sub);
-
-                dbus_connection_send(connection, reply, NULL);
-                dbus_message_unref(reply);
-        } else if (strcmp(property, "IsStatusNotifierHostRegistered") == 0) {
-                DBusMessage *reply;
-                DBusMessageIter iter;
-                DBusMessageIter sub;
-                int registered = (hosts == NULL || hosts->length == 0) ? 0 : 1;
-
-                reply = dbus_message_new_method_return(message);
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
-                                "b", &sub);
-                dbus_message_iter_append_basic(&sub,
-                                DBUS_TYPE_BOOLEAN, &registered);
-
-                dbus_message_iter_close_container(&iter, &sub);
-
-                dbus_connection_send(connection, reply, NULL);
-                dbus_message_unref(reply);
-        } else if (strcmp(property, "ProtocolVersion") == 0) {
-                DBusMessage *reply;
-                DBusMessageIter iter;
-                DBusMessageIter sub;
-                const int version = 0;
-
-                reply = dbus_message_new_method_return(message);
-
-                dbus_message_iter_init_append(reply, &iter);
-
-                dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
-                                "i", &sub);
-                dbus_message_iter_append_basic(&sub,
-                                DBUS_TYPE_INT32, &version);
-
-                dbus_message_iter_close_container(&iter, &sub);
-                dbus_connection_send(connection, reply, NULL);
-                dbus_message_unref(reply);
-        }
-}
-
-static void set_property(DBusConnection *connection, DBusMessage *message) {
-        // All properties are read only and we don't allow new properties
-        return;
-}
-
-static void get_all(DBusConnection *connection, DBusMessage *message) {
-        DBusMessage *reply;
-        reply = dbus_message_new_method_return(message);
-        DBusMessageIter iter; /* a{v} */
-        DBusMessageIter arr;
-        DBusMessageIter dict;
-        DBusMessageIter sub;
-        DBusMessageIter subsub;
-        int registered = (hosts == NULL || hosts->length == 0) ? 0 : 1;
-        const int version = 0;
-        const char *prop;
-
-        // Could clean this up with a function for each prop
-        dbus_message_iter_init_append(reply, &iter);
-        dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-                        "{sv}", &arr);
-
-        prop = "RegisteredStatusNotifierItems";
-        dbus_message_iter_open_container(&arr, DBUS_TYPE_DICT_ENTRY,
-                        NULL, &dict);
-        dbus_message_iter_append_basic(&dict,
-                        DBUS_TYPE_STRING, &prop);
-        dbus_message_iter_open_container(&dict, DBUS_TYPE_VARIANT,
-                        "as", &sub);
-        dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY,
-                        "s", &subsub);
-        for (int i = 0; i < items->length; ++i) {
-                dbus_message_iter_append_basic(&subsub,
-                                DBUS_TYPE_STRING, &items->items[i]);
-        }
-        dbus_message_iter_close_container(&sub, &subsub);
-        dbus_message_iter_close_container(&dict, &sub);
-        dbus_message_iter_close_container(&arr, &dict);
-
-        prop = "IsStatusNotifierHostRegistered";
-        dbus_message_iter_open_container(&arr, DBUS_TYPE_DICT_ENTRY,
-                        NULL, &dict);
-        dbus_message_iter_append_basic(&dict,
-                        DBUS_TYPE_STRING, &prop);
-        dbus_message_iter_open_container(&dict, DBUS_TYPE_VARIANT,
-                        "b", &sub);
-        dbus_message_iter_append_basic(&sub,
-                        DBUS_TYPE_BOOLEAN, &registered);
-        dbus_message_iter_close_container(&dict, &sub);
-        dbus_message_iter_close_container(&arr, &dict);
-
-        prop = "ProtocolVersion";
-        dbus_message_iter_open_container(&arr, DBUS_TYPE_DICT_ENTRY,
-                        NULL, &dict);
-        dbus_message_iter_append_basic(&dict,
-                        DBUS_TYPE_STRING, &prop);
-        dbus_message_iter_open_container(&dict, DBUS_TYPE_VARIANT,
-                        "i", &sub);
-        dbus_message_iter_append_basic(&sub,
-                        DBUS_TYPE_INT32, &version);
-        dbus_message_iter_close_container(&dict, &sub);
-        dbus_message_iter_close_container(&arr, &dict);
-
-        dbus_message_iter_close_container(&iter, &arr);
-
-        dbus_connection_send(connection, reply, NULL);
-        dbus_message_unref(reply);
-}
-
-static DBusHandlerResult message_handler(DBusConnection *connection, 
-                DBusMessage *message, void *data) {
-        const char *interface_name = dbus_message_get_interface(message);
-        const char *member_name = dbus_message_get_member(message);
-
-        // In order of the xml above
-        if (strcmp(interface_name, "org.freedesktop.DBus.Introspectable") == 0 &&
-                        strcmp(member_name, "Introspect") == 0) {
-                // We don't have an introspect for KDE
-                respond_to_introspect(connection, message);
-                return DBUS_HANDLER_RESULT_HANDLED;
-        } else if (strcmp(interface_name, "org.freedesktop.DBus.Properties") == 0) {
-                if (strcmp(member_name, "Get") == 0) {
-                        get_property(connection, message);
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                } else if (strcmp(member_name, "Set") == 0) {
-                        set_property(connection, message);
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                } else if (strcmp(member_name, "GetAll") == 0) {
-                        get_all(connection, message);
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                } else {
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-        } else if (strcmp(interface_name, "org.freedesktop.StatusNotifierWatcher") == 0 ||
-                        strcmp(interface_name, "org.kde.StatusNotifierWatcher") == 0) {
-                if (strcmp(member_name, "RegisterStatusNotifierItem") == 0) {
-                        register_item(connection, message);
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                } else if (strcmp(member_name, "RegisterStatusNotifierHost") == 0) {
-                        register_host(connection, message);
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                } else {
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-        }
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-}
-
-static DBusHandlerResult signal_handler(DBusConnection *connection,
-                DBusMessage *message, void *_data) {
-        if (dbus_message_is_signal(message, "org.freedesktop.DBus", "NameOwnerChanged")) {
-                // Only eat the message if it is name that we are watching
-                const char *name;
-                const char *old_owner;
-                const char *new_owner;
-                int index;
-                if (!dbus_message_get_args(message, NULL,
-                                DBUS_TYPE_STRING, &name,
-                                DBUS_TYPE_STRING, &old_owner,
-                                DBUS_TYPE_STRING, &new_owner,
-                                DBUS_TYPE_INVALID)) {
-                        sway_log(L_ERROR, "Error getting LostName args");
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-                if (strcmp(new_owner, "") != 0) {
-                        // Name is not lost
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-                if ((index = list_seq_find(items, (int (*)(const void *, const void *))strcmp, name)) != -1) {
-                        sway_log(L_INFO, "Status Notifier Item lost %s", name);
-                        free(items->items[index]);
-                        list_del(items, index);
-                        item_unregistered_signal(connection, name);
-
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                }
-                if ((index = list_seq_find(hosts, (int (*)(const void *, const void *))strcmp, name)) != -1) {
-                        sway_log(L_INFO, "Status Notifier Host lost %s", name);
-                        free(hosts->items[index]);
-                        list_del(hosts, index);
-
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                }
-        }
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-}
-
-static const DBusObjectPathVTable vtable = {
-        .message_function = message_handler,
-        .unregister_function = NULL,
-};
-
-int init_sni_watcher() {
-        DBusError error;
-        dbus_error_init(&error);
-        if (!conn) {
-                sway_log(L_ERROR, "Connection is null, cannot initiate StatusNotifierWatcher");
-                return -1;
-        }
-
-        items = create_list();
-        hosts = create_list();
-
-        int status = dbus_bus_request_name(conn, "org.freedesktop.StatusNotifierWatcher",
-                        DBUS_NAME_FLAG_REPLACE_EXISTING,
-                        &error);
-        if (status == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
-                sway_log(L_DEBUG, "Got watcher name");
-        } else if (status == DBUS_REQUEST_NAME_REPLY_IN_QUEUE) {
-                sway_log(L_INFO, "Could not get watcher name, it may start later");
-        }
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus err getting watcher name: %s\n", error.message);
-                return -1;
-        }
-
-        status = dbus_bus_request_name(conn, "org.kde.StatusNotifierWatcher",
-                        DBUS_NAME_FLAG_REPLACE_EXISTING,
-                        &error);
-        if (status == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
-                sway_log(L_DEBUG, "Got kde watcher name");
-        } else if (status == DBUS_REQUEST_NAME_REPLY_IN_QUEUE) {
-                sway_log(L_INFO, "Could not get kde watcher name, it may start later");
-        }
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus err getting kde watcher name: %s\n", error.message);
-                return -1;
-        }
-
-        dbus_connection_try_register_object_path(conn,
-                        "/StatusNotifierWatcher",
-                        &vtable, NULL, &error);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus_err: %s\n", error.message);
-                return -1;
-        }
-
-        dbus_bus_add_match(conn,
-                        "type='signal',\
-                        sender='org.freedesktop.DBus',\
-                        interface='org.freedesktop.DBus',\
-                        member='NameOwnerChanged'",
-                        &error);
-
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "DBus error getting match args: %s", error.message);
-        }
-
-        dbus_connection_add_filter(conn, signal_handler, NULL, NULL);
-        return 0;
-}
diff --git a/swaybar/tray/tray.c b/swaybar/tray/tray.c
deleted file mode 100644
index 91c3af06..00000000
--- a/swaybar/tray/tray.c
+++ /dev/null
@@ -1,398 +0,0 @@
-#define _XOPEN_SOURCE 700
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/wait.h>
-#include <dbus/dbus.h>
-#include "swaybar/bar.h"
-#include "swaybar/tray/tray.h"
-#include "swaybar/tray/dbus.h"
-#include "swaybar/tray/sni.h"
-#include "swaybar/tray/sni_watcher.h"
-#include "swaybar/bar.h"
-#include "swaybar/config.h"
-#include "list.h"
-#include "log.h"
-
-struct tray *tray;
-
-static void register_host(char *name) {
-        DBusMessage *message;
-
-        message = dbus_message_new_method_call(
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "/StatusNotifierWatcher",
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "RegisterStatusNotifierHost");
-        if (!message) {
-                sway_log(L_ERROR, "Cannot allocate dbus method call");
-                return;
-        }
-
-        dbus_message_append_args(message,
-                        DBUS_TYPE_STRING, &name,
-                        DBUS_TYPE_INVALID);
-
-        dbus_connection_send(conn, message, NULL);
-
-        dbus_message_unref(message);
-}
-
-static void get_items_reply(DBusPendingCall *pending, void *_data) {
-        DBusMessage *reply = dbus_pending_call_steal_reply(pending);
-
-        if (!reply) {
-                sway_log(L_ERROR, "Got no items reply from sni watcher");
-                goto bail;
-        }
-
-        int message_type = dbus_message_get_type(reply);
-
-        if (message_type == DBUS_MESSAGE_TYPE_ERROR) {
-                char *msg;
-
-                dbus_message_get_args(reply, NULL,
-                                DBUS_TYPE_STRING, &msg,
-                                DBUS_TYPE_INVALID);
-
-                sway_log(L_ERROR, "Message is error: %s", msg);
-                goto bail;
-        }
-
-        DBusMessageIter iter;
-        DBusMessageIter variant;
-        DBusMessageIter array;
-
-        dbus_message_iter_init(reply, &iter);
-        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
-                sway_log(L_ERROR, "Replyed with wrong type, not v(as)");
-                goto bail;
-        }
-        dbus_message_iter_recurse(&iter, &variant);
-        if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY ||
-                        dbus_message_iter_get_element_type(&variant) != DBUS_TYPE_STRING) {
-                sway_log(L_ERROR, "Replyed with wrong type, not v(as)");
-                goto bail;
-        }
-
-        // Clear list
-        list_foreach(tray->items, (void (*)(void *))sni_free);
-        list_free(tray->items);
-        tray->items = create_list();
-
-        // O(n) function, could be faster dynamically reading values
-        int len = dbus_message_iter_get_element_count(&variant);
-
-        dbus_message_iter_recurse(&variant, &array);
-        for (int i = 0; i < len; i++) {
-                const char *name;
-                dbus_message_iter_get_basic(&array, &name);
-
-                struct StatusNotifierItem *item = sni_create(name);
-
-                if (item) {
-                        sway_log(L_DEBUG, "Item registered with host: %s", name);
-                        list_add(tray->items, item);
-                        dirty = true;
-                }
-        }
-
-bail:
-        dbus_message_unref(reply);
-        dbus_pending_call_unref(pending);
-        return;
-}
-static void get_items() {
-        DBusPendingCall *pending;
-        DBusMessage *message = dbus_message_new_method_call(
-                        "org.freedesktop.StatusNotifierWatcher",
-                        "/StatusNotifierWatcher",
-                        "org.freedesktop.DBus.Properties",
-                        "Get");
-
-        const char *iface = "org.freedesktop.StatusNotifierWatcher";
-        const char *prop = "RegisteredStatusNotifierItems";
-        dbus_message_append_args(message,
-                        DBUS_TYPE_STRING, &iface,
-                        DBUS_TYPE_STRING, &prop,
-                        DBUS_TYPE_INVALID);
-
-        bool status =
-                dbus_connection_send_with_reply(conn, message, &pending, -1);
-        dbus_message_unref(message);
-
-        if (!(pending || status)) {
-                sway_log(L_ERROR, "Could not get items");
-                return;
-        }
-
-        dbus_pending_call_set_notify(pending, get_items_reply, NULL, NULL);
-}
-
-static DBusHandlerResult signal_handler(DBusConnection *connection,
-                DBusMessage *message, void *_data) {
-        if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierWatcher",
-                                "StatusNotifierItemRegistered")) {
-                const char *name;
-                if (!dbus_message_get_args(message, NULL,
-                                DBUS_TYPE_STRING, &name,
-                                DBUS_TYPE_INVALID)) {
-                        sway_log(L_ERROR, "Error getting StatusNotifierItemRegistered args");
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-
-                if (list_seq_find(tray->items, sni_str_cmp, name) == -1) {
-                        struct StatusNotifierItem *item = sni_create(name);
-
-                        if (item) {
-                                list_add(tray->items, item);
-                                dirty = true;
-                        }
-                }
-
-                return DBUS_HANDLER_RESULT_HANDLED;
-        } else if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierWatcher",
-                                "StatusNotifierItemUnregistered")) {
-                const char *name;
-                if (!dbus_message_get_args(message, NULL,
-                                DBUS_TYPE_STRING, &name,
-                                DBUS_TYPE_INVALID)) {
-                        sway_log(L_ERROR, "Error getting StatusNotifierItemUnregistered args");
-                        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-                }
-
-                int index;
-                if ((index = list_seq_find(tray->items, sni_str_cmp, name)) != -1) {
-                        sni_free(tray->items->items[index]);
-                        list_del(tray->items, index);
-                        dirty = true;
-                } else {
-                        // If it's not in our list, then our list is incorrect.
-                        // Fetch all items again
-                        sway_log(L_INFO, "Host item list incorrect, refreshing");
-                        get_items();
-                }
-
-                return DBUS_HANDLER_RESULT_HANDLED;
-        } else if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierItem",
-                                "NewIcon") || dbus_message_is_signal(message,
-                                "org.kde.StatusNotifierItem", "NewIcon")) {
-                const char *name;
-                int index;
-                struct StatusNotifierItem *item;
-
-                name = dbus_message_get_sender(message);
-                if ((index = list_seq_find(tray->items, sni_uniq_cmp, name)) != -1) {
-                        item = tray->items->items[index];
-                        sway_log(L_INFO, "NewIcon signal from item %s", item->name);
-                        get_icon(item);
-                }
-
-                return DBUS_HANDLER_RESULT_HANDLED;
-        }
-        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-}
-
-static int init_host() {
-        tray = (struct tray *)malloc(sizeof(tray));
-
-        tray->items = create_list();
-
-        DBusError error;
-        dbus_error_init(&error);
-        char *name = NULL;
-        if (!conn) {
-                sway_log(L_ERROR, "Connection is null, cannot init SNI host");
-                goto err;
-        }
-        name = calloc(sizeof(char), 256);
-
-        if (!name) {
-                sway_log(L_ERROR, "Cannot allocate name");
-                goto err;
-        }
-
-        pid_t pid = getpid();
-        if (snprintf(name, 256, "org.freedesktop.StatusNotifierHost-%d", pid)
-                        >= 256) {
-                sway_log(L_ERROR, "Cannot get host name because string is too short."
-                                "This should not happen");
-                goto err;
-        }
-
-        // We want to be the sole owner of this name
-        if (dbus_bus_request_name(conn, name, DBUS_NAME_FLAG_DO_NOT_QUEUE,
-                        &error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
-                sway_log(L_ERROR, "Cannot get host name and start the tray");
-                goto err;
-        }
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "Dbus err getting host name: %s\n", error.message);
-                goto err;
-        }
-        sway_log(L_DEBUG, "Got host name");
-
-        register_host(name);
-
-        get_items();
-
-        // Perhaps use addmatch helper functions like wlc does?
-        dbus_bus_add_match(conn,
-                        "type='signal',\
-                        sender='org.freedesktop.StatusNotifierWatcher',\
-                        member='StatusNotifierItemRegistered'",
-                        &error);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus_err: %s", error.message);
-                goto err;
-        }
-        dbus_bus_add_match(conn,
-                        "type='signal',\
-                        sender='org.freedesktop.StatusNotifierWatcher',\
-                        member='StatusNotifierItemUnregistered'",
-                        &error);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus_err: %s", error.message);
-                return -1;
-        }
-
-        // SNI matches
-        dbus_bus_add_match(conn,
-                        "type='signal',\
-                        interface='org.freedesktop.StatusNotifierItem',\
-                        member='NewIcon'",
-                        &error);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus_err %s", error.message);
-                goto err;
-        }
-        dbus_bus_add_match(conn,
-                        "type='signal',\
-                        interface='org.kde.StatusNotifierItem',\
-                        member='NewIcon'",
-                        &error);
-        if (dbus_error_is_set(&error)) {
-                sway_log(L_ERROR, "dbus_err %s", error.message);
-                goto err;
-        }
-
-        dbus_connection_add_filter(conn, signal_handler, NULL, NULL);
-
-        free(name);
-        return 0;
-
-err:
-        // TODO better handle errors
-        free(name);
-        return -1;
-}
-
-void tray_mouse_event(struct output *output, int x, int y,
-                uint32_t button, uint32_t state) {
-
-        struct window *window = output->window;
-        uint32_t tray_padding = swaybar.config->tray_padding;
-        int tray_width = window->width * window->scale;
-
-        for (int i = 0; i < output->items->length; ++i) {
-                struct sni_icon_ref *item =
-                         output->items->items[i];
-                int icon_width = cairo_image_surface_get_width(item->icon);
-
-                tray_width -= tray_padding;
-                if (x <= tray_width && x >= tray_width - icon_width) {
-                        if (button == swaybar.config->activate_button) {
-                                sni_activate(item->ref, x, y);
-                        } else if (button == swaybar.config->context_button) {
-                                sni_context_menu(item->ref, x, y);
-                        } else if (button == swaybar.config->secondary_button) {
-                                sni_secondary(item->ref, x, y);
-                        }
-                        break;
-                }
-                tray_width -= icon_width;
-        }
-}
-
-uint32_t tray_render(struct output *output, struct config *config) {
-        struct window *window = output->window;
-        cairo_t *cairo = window->cairo;
-
-        // Tray icons
-        uint32_t tray_padding = config->tray_padding;
-        uint32_t tray_width = window->width * window->scale;
-        const int item_size = (window->height * window->scale) - (2 * tray_padding);
-
-        if (item_size < 0) {
-                // Can't render items if the padding is too large
-                return tray_width;
-        }
-
-        if (config->tray_output && strcmp(config->tray_output, output->name) != 0) {
-                return tray_width;
-        }
-
-        for (int i = 0; i < tray->items->length; ++i) {
-                struct StatusNotifierItem *item =
-                        tray->items->items[i];
-                if (!item->image) {
-                        continue;
-                }
-
-                struct sni_icon_ref *render_item = NULL;
-                int j;
-                for (j = i; j < output->items->length; ++j) {
-                        struct sni_icon_ref *ref =
-                                output->items->items[j];
-                        if (ref->ref == item) {
-                                render_item = ref;
-                                break;
-                        } else {
-                                sni_icon_ref_free(ref);
-                                list_del(output->items, j);
-                        }
-                }
-
-                if (!render_item) {
-                        render_item = sni_icon_ref_create(item, item_size);
-                        list_add(output->items, render_item);
-                } else if (item->dirty) {
-                        // item needs re-render
-                        sni_icon_ref_free(render_item);
-                        output->items->items[j] = render_item =
-                                sni_icon_ref_create(item, item_size);
-                }
-
-                tray_width -= tray_padding;
-                tray_width -= item_size;
-
-                cairo_operator_t op = cairo_get_operator(cairo);
-                cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
-                cairo_set_source_surface(cairo, render_item->icon, tray_width, tray_padding);
-                cairo_rectangle(cairo, tray_width, tray_padding, item_size, item_size);
-                cairo_fill(cairo);
-                cairo_set_operator(cairo, op);
-
-                item->dirty = false;
-        }
-
-
-        if (tray_width != window->width * window->scale) {
-                tray_width -= tray_padding;
-        }
-
-        return tray_width;
-}
-
-void init_tray(struct bar *bar) {
-        if (!bar->config->tray_output || strcmp(bar->config->tray_output, "none") != 0) {
-                /* Connect to the D-Bus */
-                dbus_init();
-
-                /* Start the SNI watcher */
-                init_sni_watcher();
-
-                /* Start the SNI host */
-                init_host();
-        }
-}