Systray patch

10 files changed, 1855 insertions, 0 deletions

diff --git a/systray/helpers.c b/systray/helpers.c
new file mode 100644
index 0000000..d1af9f8
--- /dev/null
+++ b/systray/helpers.c
@@ -0,0 +1,43 @@
+#include "helpers.h"
+
+#include <dbus/dbus.h>
+
+#include <errno.h>
+#include <stddef.h>
+
+// IWYU pragma: no_include "dbus/dbus-protocol.h"
+// IWYU pragma: no_include "dbus/dbus-shared.h"
+
+int
+request_property(DBusConnection *conn, const char *busname, const char *busobj,
+                 const char *prop, const char *iface, PropHandler handler,
+                 void *data)
+{
+	DBusMessage *msg = NULL;
+	DBusPendingCall *pending = NULL;
+	int r;
+
+	if (!(msg = dbus_message_new_method_call(busname, busobj,
+	                                         DBUS_INTERFACE_PROPERTIES,
+	                                         "Get")) ||
+	    !dbus_message_append_args(msg, DBUS_TYPE_STRING, &iface,
+	                              DBUS_TYPE_STRING, &prop,
+	                              DBUS_TYPE_INVALID) ||
+	    !dbus_connection_send_with_reply(conn, msg, &pending, -1) ||
+	    !dbus_pending_call_set_notify(pending, handler, data, NULL)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_unref(msg);
+	return 0;
+
+fail:
+	if (pending) {
+		dbus_pending_call_cancel(pending);
+		dbus_pending_call_unref(pending);
+	}
+	if (msg)
+		dbus_message_unref(msg);
+	return r;
+}
diff --git a/systray/helpers.h b/systray/helpers.h
new file mode 100644
index 0000000..2c592e0
--- /dev/null
+++ b/systray/helpers.h
@@ -0,0 +1,12 @@
+#ifndef HELPERS_H
+#define HELPERS_H
+
+#include <dbus/dbus.h>
+
+typedef void (*PropHandler)(DBusPendingCall *pcall, void *data);
+
+int request_property (DBusConnection *conn, const char *busname,
+                      const char *busobj, const char *prop, const char *iface,
+                      PropHandler handler, void *data);
+
+#endif /* HELPERS_H */
diff --git a/systray/icon.c b/systray/icon.c
new file mode 100644
index 0000000..1b97866
--- /dev/null
+++ b/systray/icon.c
@@ -0,0 +1,149 @@
+#include "icon.h"
+
+#include <fcft/fcft.h>
+#include <pixman.h>
+
+#include <ctype.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PREMUL_ALPHA(chan, alpha) (chan * alpha + 127) / 255
+
+/*
+ * Converts pixels from uint8_t[4] to uint32_t and
+ * straight alpha to premultiplied alpha.
+ */
+static uint32_t *
+to_pixman(const uint8_t *src, int n_pixels, size_t *pix_size)
+{
+	uint32_t *dest = NULL;
+
+	*pix_size = n_pixels * sizeof(uint32_t);
+	dest = malloc(*pix_size);
+	if (!dest)
+		return NULL;
+
+	for (int i = 0; i < n_pixels; i++) {
+		uint8_t a = src[i * 4 + 0];
+		uint8_t r = src[i * 4 + 1];
+		uint8_t g = src[i * 4 + 2];
+		uint8_t b = src[i * 4 + 3];
+
+		/*
+		 * Skip premultiplying fully opaque and fully transparent
+		 * pixels.
+		 */
+		if (a == 0) {
+			dest[i] = 0;
+
+		} else if (a == 255) {
+			dest[i] = ((uint32_t)a << 24) | ((uint32_t)r << 16) |
+			          ((uint32_t)g << 8) | ((uint32_t)b);
+
+		} else {
+			dest[i] = ((uint32_t)a << 24) |
+			          ((uint32_t)PREMUL_ALPHA(r, a) << 16) |
+			          ((uint32_t)PREMUL_ALPHA(g, a) << 8) |
+			          ((uint32_t)PREMUL_ALPHA(b, a));
+		}
+	}
+
+	return dest;
+}
+
+Icon *
+createicon(const uint8_t *buf, int width, int height, int size)
+{
+	Icon *icon = NULL;
+
+	int n_pixels;
+	pixman_image_t *img = NULL;
+	size_t pixbuf_size;
+	uint32_t *buf_pixman = NULL;
+	uint8_t *buf_orig = NULL;
+
+	n_pixels = size / 4;
+
+	icon = calloc(1, sizeof(Icon));
+	buf_orig = malloc(size);
+	buf_pixman = to_pixman(buf, n_pixels, &pixbuf_size);
+	if (!icon || !buf_orig || !buf_pixman)
+		goto fail;
+
+	img = pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height,
+	                               buf_pixman, width * 4);
+	if (!img)
+		goto fail;
+
+	memcpy(buf_orig, buf, size);
+
+	icon->buf_orig = buf_orig;
+	icon->buf_pixman = buf_pixman;
+	icon->img = img;
+	icon->size_orig = size;
+	icon->size_pixman = pixbuf_size;
+
+	return icon;
+
+fail:
+	free(buf_orig);
+	if (img)
+		pixman_image_unref(img);
+	free(buf_pixman);
+	free(icon);
+	return NULL;
+}
+
+void
+destroyicon(Icon *icon)
+{
+	if (icon->img)
+		pixman_image_unref(icon->img);
+	free(icon->buf_orig);
+	free(icon->buf_pixman);
+	free(icon);
+}
+
+FallbackIcon *
+createfallbackicon(const char *appname, int fgcolor, struct fcft_font *font)
+{
+	const struct fcft_glyph *glyph;
+	char initial;
+
+	if ((unsigned char)appname[0] > 127) {
+		/* first character is not ascii */
+		initial = '?';
+	} else {
+		initial = toupper(*appname);
+	}
+
+	glyph = fcft_rasterize_char_utf32(font, initial, FCFT_SUBPIXEL_DEFAULT);
+	if (!glyph)
+		return NULL;
+
+	return glyph;
+}
+
+int
+resize_image(pixman_image_t *image, int new_width, int new_height)
+{
+	int src_width = pixman_image_get_width(image);
+	int src_height = pixman_image_get_height(image);
+	pixman_transform_t transform;
+	pixman_fixed_t scale_x, scale_y;
+
+	if (src_width == new_width && src_height == new_height)
+		return 0;
+
+	scale_x = pixman_double_to_fixed((double)src_width / new_width);
+	scale_y = pixman_double_to_fixed((double)src_height / new_height);
+
+	pixman_transform_init_scale(&transform, scale_x, scale_y);
+	if (!pixman_image_set_filter(image, PIXMAN_FILTER_BEST, NULL, 0) ||
+	    !pixman_image_set_transform(image, &transform)) {
+		return -1;
+	}
+
+	return 0;
+}
diff --git a/systray/icon.h b/systray/icon.h
new file mode 100644
index 0000000..20f281b
--- /dev/null
+++ b/systray/icon.h
@@ -0,0 +1,26 @@
+#ifndef ICON_H
+#define ICON_H
+
+#include <fcft/fcft.h>
+#include <pixman.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef const struct fcft_glyph FallbackIcon;
+
+typedef struct {
+	pixman_image_t *img;
+	uint32_t *buf_pixman;
+	uint8_t *buf_orig;
+	size_t size_orig;
+	size_t size_pixman;
+} Icon;
+
+Icon *createicon (const uint8_t *buf, int width, int height, int size);
+FallbackIcon *createfallbackicon (const char *appname, int fgcolor,
+                                  struct fcft_font *font);
+void destroyicon (Icon *icon);
+int resize_image (pixman_image_t *orig, int new_width, int new_height);
+
+#endif /* ICON_H */
diff --git a/systray/menu.c b/systray/menu.c
new file mode 100644
index 0000000..ff3bfb5
--- /dev/null
+++ b/systray/menu.c
@@ -0,0 +1,757 @@
+#include "menu.h"
+
+#include <dbus/dbus.h>
+#include <wayland-server-core.h>
+#include <wayland-util.h>
+
+#include <errno.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <unistd.h>
+
+// IWYU pragma: no_include "dbus/dbus-protocol.h"
+// IWYU pragma: no_include "dbus/dbus-shared.h"
+
+#define DBUSMENU_IFACE "com.canonical.dbusmenu"
+#define BUFSIZE 512
+#define LABEL_MAX 64
+
+typedef struct {
+	struct wl_array layout;
+	DBusConnection *conn;
+	struct wl_event_loop *loop;
+	char *busname;
+	char *busobj;
+	const char **menucmd;
+} Menu;
+
+typedef struct {
+	char label[LABEL_MAX];
+	dbus_int32_t id;
+	struct wl_array submenu;
+	int has_submenu;
+} MenuItem;
+
+typedef struct {
+	struct wl_event_loop *loop;
+	struct wl_event_source *fd_source;
+	struct wl_array *layout_node;
+	Menu *menu;
+	pid_t menu_pid;
+	int fd;
+} MenuShowContext;
+
+static int extract_menu (DBusMessageIter *av, struct wl_array *menu);
+static int real_show_menu (Menu *menu, struct wl_array *m);
+static void submenus_destroy_recursive (struct wl_array *m);
+
+static void
+menuitem_init(MenuItem *mi)
+{
+	wl_array_init(&mi->submenu);
+	mi->id = -1;
+	*mi->label = '\0';
+	mi->has_submenu = 0;
+}
+
+static void
+submenus_destroy_recursive(struct wl_array *layout_node)
+{
+	MenuItem *mi;
+
+	wl_array_for_each(mi, layout_node) {
+		if (mi->has_submenu) {
+			submenus_destroy_recursive(&mi->submenu);
+			wl_array_release(&mi->submenu);
+		}
+	}
+}
+
+static void
+menu_destroy(Menu *menu)
+{
+	submenus_destroy_recursive(&menu->layout);
+	wl_array_release(&menu->layout);
+	free(menu->busname);
+	free(menu->busobj);
+	free(menu);
+}
+
+static void
+menu_show_ctx_finalize(MenuShowContext *ctx, int error)
+{
+	if (ctx->fd_source)
+		wl_event_source_remove(ctx->fd_source);
+
+	if (ctx->fd >= 0)
+		close(ctx->fd);
+
+	if (ctx->menu_pid >= 0) {
+		if (waitpid(ctx->menu_pid, NULL, WNOHANG) == 0)
+			kill(ctx->menu_pid, SIGTERM);
+	}
+
+	if (error)
+		menu_destroy(ctx->menu);
+
+	free(ctx);
+}
+
+static void
+remove_newline(char *buf)
+{
+	size_t len;
+
+	len = strlen(buf);
+	if (len > 0 && buf[len - 1] == '\n')
+		buf[len - 1] = '\0';
+}
+
+static void
+send_clicked(const char *busname, const char *busobj, int itemid,
+             DBusConnection *conn)
+{
+	DBusMessage *msg = NULL;
+	DBusMessageIter iter = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	DBusMessageIter sub = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	const char *data = "";
+	const char *eventid = "clicked";
+	time_t timestamp;
+
+	timestamp = time(NULL);
+
+	msg = dbus_message_new_method_call(busname, busobj, DBUSMENU_IFACE,
+	                                   "Event");
+	if (!msg)
+		goto fail;
+
+	dbus_message_iter_init_append(msg, &iter);
+	if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &itemid) ||
+	    !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+	                                    &eventid) ||
+	    !dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+	                                      DBUS_TYPE_STRING_AS_STRING,
+	                                      &sub) ||
+	    !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &data) ||
+	    !dbus_message_iter_close_container(&iter, &sub) ||
+	    !dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32,
+	                                    &timestamp)) {
+		goto fail;
+	}
+
+	if (!dbus_connection_send_with_reply(conn, msg, NULL, -1))
+		goto fail;
+
+	dbus_message_unref(msg);
+	return;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(&iter, &sub);
+	if (msg)
+		dbus_message_unref(msg);
+}
+
+static void
+menuitem_selected(const char *label, struct wl_array *m, Menu *menu)
+{
+	MenuItem *mi;
+
+	wl_array_for_each(mi, m) {
+		if (strcmp(mi->label, label) == 0) {
+			if (mi->has_submenu) {
+				real_show_menu(menu, &mi->submenu);
+
+			} else {
+				send_clicked(menu->busname, menu->busobj,
+				             mi->id, menu->conn);
+				menu_destroy(menu);
+			}
+
+			return;
+		}
+	}
+}
+
+static int
+read_pipe(int fd, uint32_t mask, void *data)
+{
+	MenuShowContext *ctx = data;
+
+	char buf[BUFSIZE];
+	ssize_t bytes_read;
+
+	bytes_read = read(fd, buf, BUFSIZE);
+	/* 0 == Got EOF, menu program closed without writing to stdout */
+	if (bytes_read <= 0)
+		goto fail;
+
+	buf[bytes_read] = '\0';
+	remove_newline(buf);
+
+	menuitem_selected(buf, ctx->layout_node, ctx->menu);
+	menu_show_ctx_finalize(ctx, 0);
+	return 0;
+
+fail:
+	menu_show_ctx_finalize(ctx, 1);
+	return 0;
+}
+
+static MenuShowContext *
+prepare_show_ctx(struct wl_event_loop *loop, int monitor_fd, int dmenu_pid,
+                 struct wl_array *layout_node, Menu *menu)
+{
+	MenuShowContext *ctx = NULL;
+	struct wl_event_source *fd_src = NULL;
+
+	ctx = calloc(1, sizeof(MenuShowContext));
+	if (!ctx)
+		goto fail;
+
+	fd_src = wl_event_loop_add_fd(menu->loop, monitor_fd, WL_EVENT_READABLE,
+	                              read_pipe, ctx);
+	if (!fd_src)
+		goto fail;
+
+	ctx->fd_source = fd_src;
+	ctx->fd = monitor_fd;
+	ctx->menu_pid = dmenu_pid;
+	ctx->layout_node = layout_node;
+	ctx->menu = menu;
+
+	return ctx;
+
+fail:
+	if (fd_src)
+		wl_event_source_remove(fd_src);
+	free(ctx);
+	return NULL;
+}
+
+static int
+write_dmenu_buf(char *buf, struct wl_array *layout_node)
+{
+	MenuItem *mi;
+	int r;
+	size_t curlen = 0;
+
+	*buf = '\0';
+
+	wl_array_for_each(mi, layout_node) {
+		curlen += strlen(mi->label) +
+		          2; /* +2 is newline + nul terminator */
+		if (curlen + 1 > BUFSIZE) {
+			r = -1;
+			goto fail;
+		}
+
+		strcat(buf, mi->label);
+		strcat(buf, "\n");
+	}
+	remove_newline(buf);
+
+	return 0;
+
+fail:
+	fprintf(stderr, "Failed to construct dmenu input\n");
+	return r;
+}
+
+static int
+real_show_menu(Menu *menu, struct wl_array *layout_node)
+{
+	MenuShowContext *ctx = NULL;
+	char buf[BUFSIZE];
+	int to_pipe[2], from_pipe[2];
+	pid_t pid;
+
+	if (pipe(to_pipe) < 0 || pipe(from_pipe) < 0)
+		goto fail;
+
+	pid = fork();
+	if (pid < 0) {
+		goto fail;
+	} else if (pid == 0) {
+		dup2(to_pipe[0], STDIN_FILENO);
+		dup2(from_pipe[1], STDOUT_FILENO);
+
+		close(to_pipe[0]);
+		close(to_pipe[1]);
+		close(from_pipe[1]);
+		close(from_pipe[0]);
+
+		if (execvp(menu->menucmd[0], (char *const *)menu->menucmd)) {
+			perror("Error spawning menu program");
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	ctx = prepare_show_ctx(menu->loop, from_pipe[0], pid, layout_node,
+	                       menu);
+	if (!ctx)
+		goto fail;
+
+	if (write_dmenu_buf(buf, layout_node) < 0 ||
+	    write(to_pipe[1], buf, strlen(buf)) < 0) {
+		goto fail;
+	}
+
+	close(to_pipe[0]);
+	close(to_pipe[1]);
+	close(from_pipe[1]);
+	return 0;
+
+fail:
+	close(to_pipe[0]);
+	close(to_pipe[1]);
+	close(from_pipe[1]);
+	menu_show_ctx_finalize(ctx, 1);
+	return -1;
+}
+
+static void
+createmenuitem(MenuItem *mi, dbus_int32_t id, const char *label,
+               int toggle_state, int has_submenu)
+{
+	char *tok;
+	char temp[LABEL_MAX];
+
+	if (toggle_state == 0)
+		strcpy(mi->label, "☐ ");
+	else if (toggle_state == 1)
+		strcpy(mi->label, "✓ ");
+	else
+		strcpy(mi->label, "  ");
+
+	/* Remove "mnemonics" (underscores which mark keyboard shortcuts) */
+	strcpy(temp, label);
+	tok = strtok(temp, "_");
+	do {
+		strcat(mi->label, tok);
+	} while ((tok = strtok(NULL, "_")));
+
+	if (has_submenu) {
+		mi->has_submenu = 1;
+		strcat(mi->label, " →");
+	}
+
+	mi->id = id;
+}
+
+/**
+ * Populates the passed in menuitem based on the dictionary contents.
+ *
+ * @param[in] dict
+ * @param[in] itemid
+ * @param[in] mi
+ * @param[out] has_submenu
+ * @param[out] status <0 on error, 0 on success, >0 if menuitem was skipped
+ */
+static int
+read_dict(DBusMessageIter *dict, dbus_int32_t itemid, MenuItem *mi,
+          int *has_submenu)
+{
+	DBusMessageIter member, val;
+	const char *children_display = NULL, *label = NULL, *toggle_type = NULL;
+	const char *key;
+	dbus_bool_t visible = TRUE, enabled = TRUE;
+	dbus_int32_t toggle_state = 1;
+	int r;
+
+	do {
+		dbus_message_iter_recurse(dict, &member);
+		if (dbus_message_iter_get_arg_type(&member) !=
+		    DBUS_TYPE_STRING) {
+			r = -1;
+			goto fail;
+		}
+		dbus_message_iter_get_basic(&member, &key);
+
+		dbus_message_iter_next(&member);
+		if (dbus_message_iter_get_arg_type(&member) !=
+		    DBUS_TYPE_VARIANT) {
+			r = -1;
+			goto fail;
+		}
+		dbus_message_iter_recurse(&member, &val);
+
+		if (strcmp(key, "visible") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_BOOLEAN) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &visible);
+
+		} else if (strcmp(key, "enabled") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_BOOLEAN) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &enabled);
+
+		} else if (strcmp(key, "toggle-type") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_STRING) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &toggle_type);
+
+		} else if (strcmp(key, "toggle-state") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_INT32) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &toggle_state);
+
+		} else if (strcmp(key, "children-display") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_STRING) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &children_display);
+
+			if (strcmp(children_display, "submenu") == 0)
+				*has_submenu = 1;
+
+		} else if (strcmp(key, "label") == 0) {
+			if (dbus_message_iter_get_arg_type(&val) !=
+			    DBUS_TYPE_STRING) {
+				r = -1;
+				goto fail;
+			}
+			dbus_message_iter_get_basic(&val, &label);
+		}
+	} while (dbus_message_iter_next(dict));
+
+	/* Skip hidden etc items */
+	if (!label || !visible || !enabled)
+		return 1;
+
+	/*
+	 * 4 characters for checkmark and submenu indicator,
+	 * 1 for nul terminator
+	 */
+	if (strlen(label) + 5 > LABEL_MAX) {
+		fprintf(stderr, "Too long menu entry label: %s! Skipping...\n",
+		        label);
+		return 1;
+	}
+
+	if (toggle_type && strcmp(toggle_type, "checkmark") == 0)
+		createmenuitem(mi, itemid, label, toggle_state, *has_submenu);
+	else
+		createmenuitem(mi, itemid, label, -1, *has_submenu);
+
+	return 0;
+
+fail:
+	fprintf(stderr, "Error parsing menu data\n");
+	return r;
+}
+
+/**
+ * Extracts a menuitem from a DBusMessage
+ *
+ * @param[in] strct
+ * @param[in] mi
+ * @param[out] status <0 on error, 0 on success, >0 if menuitem was skipped
+ */
+static int
+extract_menuitem(DBusMessageIter *strct, MenuItem *mi)
+{
+	DBusMessageIter val, dict;
+	dbus_int32_t itemid;
+	int has_submenu = 0;
+	int r;
+
+	dbus_message_iter_recurse(strct, &val);
+	if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_INT32) {
+		r = -1;
+		goto fail;
+	}
+	dbus_message_iter_get_basic(&val, &itemid);
+
+	if (!dbus_message_iter_next(&val) ||
+	    dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_ARRAY) {
+		r = -1;
+		goto fail;
+	}
+	dbus_message_iter_recurse(&val, &dict);
+	if (dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_DICT_ENTRY) {
+		r = -1;
+		goto fail;
+	}
+
+	r = read_dict(&dict, itemid, mi, &has_submenu);
+	if (r < 0) {
+		goto fail;
+
+	} else if (r == 0 && has_submenu) {
+		dbus_message_iter_next(&val);
+		if (dbus_message_iter_get_arg_type(&val) != DBUS_TYPE_ARRAY)
+			goto fail;
+		r = extract_menu(&val, &mi->submenu);
+		if (r < 0)
+			goto fail;
+	}
+
+	return r;
+
+fail:
+	return r;
+}
+
+static int
+extract_menu(DBusMessageIter *av, struct wl_array *layout_node)
+{
+	DBusMessageIter variant, menuitem;
+	MenuItem *mi;
+	int r;
+
+	dbus_message_iter_recurse(av, &variant);
+	if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_VARIANT) {
+		r = -1;
+		goto fail;
+	}
+
+	mi = wl_array_add(layout_node, sizeof(MenuItem));
+	if (!mi) {
+		r = -ENOMEM;
+		goto fail;
+	}
+	menuitem_init(mi);
+
+	do {
+		dbus_message_iter_recurse(&variant, &menuitem);
+		if (dbus_message_iter_get_arg_type(&menuitem) !=
+		    DBUS_TYPE_STRUCT) {
+			r = -1;
+			goto fail;
+		}
+
+		r = extract_menuitem(&menuitem, mi);
+		if (r < 0)
+			goto fail;
+		else if (r == 0) {
+			mi = wl_array_add(layout_node, sizeof(MenuItem));
+			if (!mi) {
+				r = -ENOMEM;
+				goto fail;
+			}
+			menuitem_init(mi);
+		}
+		/* r > 0: no action was performed on mi */
+	} while (dbus_message_iter_next(&variant));
+
+	return 0;
+
+fail:
+	return r;
+}
+
+static void
+layout_ready(DBusPendingCall *pending, void *data)
+{
+	Menu *menu = data;
+
+	DBusMessage *reply = NULL;
+	DBusMessageIter iter, strct;
+	dbus_uint32_t revision;
+	int r;
+
+	reply = dbus_pending_call_steal_reply(pending);
+	if (!reply || dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+		r = -1;
+		goto fail;
+	}
+
+	dbus_message_iter_init(reply, &iter);
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) {
+		r = -1;
+		goto fail;
+	}
+	dbus_message_iter_get_basic(&iter, &revision);
+
+	if (!dbus_message_iter_next(&iter) ||
+	    dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRUCT) {
+		r = -1;
+		goto fail;
+	}
+	dbus_message_iter_recurse(&iter, &strct);
+
+	/*
+	 * id 0 is the root, which contains nothing of interest.
+	 * Traverse past it.
+	 */
+	if (dbus_message_iter_get_arg_type(&strct) != DBUS_TYPE_INT32 ||
+	    !dbus_message_iter_next(&strct) ||
+	    dbus_message_iter_get_arg_type(&strct) != DBUS_TYPE_ARRAY ||
+	    !dbus_message_iter_next(&strct) ||
+	    dbus_message_iter_get_arg_type(&strct) != DBUS_TYPE_ARRAY) {
+		r = -1;
+		goto fail;
+	}
+
+	/* Root traversed over, extract the menu */
+	wl_array_init(&menu->layout);
+	r = extract_menu(&strct, &menu->layout);
+	if (r < 0)
+		goto fail;
+
+	r = real_show_menu(menu, &menu->layout);
+	if (r < 0)
+		goto fail;
+
+	dbus_message_unref(reply);
+	dbus_pending_call_unref(pending);
+	return;
+
+fail:
+	menu_destroy(menu);
+	if (reply)
+		dbus_message_unref(reply);
+	if (pending)
+		dbus_pending_call_unref(pending);
+}
+
+static int
+request_layout(Menu *menu)
+{
+	DBusMessage *msg = NULL;
+	DBusMessageIter iter = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	DBusMessageIter strings = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	DBusPendingCall *pending = NULL;
+	dbus_int32_t parentid, depth;
+	int r;
+
+	parentid = 0;
+	depth = -1;
+
+	/* menu busobj request answer didn't arrive yet. */
+	if (!menu->busobj) {
+		r = -1;
+		goto fail;
+	}
+
+	msg = dbus_message_new_method_call(menu->busname, menu->busobj,
+	                                   DBUSMENU_IFACE, "GetLayout");
+	if (!msg) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_iter_init_append(msg, &iter);
+	if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32,
+	                                    &parentid) ||
+	    !dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &depth) ||
+	    !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+	                                      DBUS_TYPE_STRING_AS_STRING,
+	                                      &strings) ||
+	    !dbus_message_iter_close_container(&iter, &strings)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	if (!dbus_connection_send_with_reply(menu->conn, msg, &pending, -1) ||
+	    !dbus_pending_call_set_notify(pending, layout_ready, menu, NULL)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_unref(msg);
+	return 0;
+
+fail:
+	if (pending) {
+		dbus_pending_call_cancel(pending);
+		dbus_pending_call_unref(pending);
+	}
+	dbus_message_iter_abandon_container_if_open(&iter, &strings);
+	if (msg)
+		dbus_message_unref(msg);
+	menu_destroy(menu);
+	return r;
+}
+
+static void
+about_to_show_handle(DBusPendingCall *pending, void *data)
+{
+	Menu *menu = data;
+
+	DBusMessage *reply = NULL;
+
+	reply = dbus_pending_call_steal_reply(pending);
+	if (!reply)
+		goto fail;
+
+	if (request_layout(menu) < 0)
+		goto fail;
+
+	dbus_message_unref(reply);
+	dbus_pending_call_unref(pending);
+	return;
+
+fail:
+	if (reply)
+		dbus_message_unref(reply);
+	if (pending)
+		dbus_pending_call_unref(pending);
+	menu_destroy(menu);
+}
+
+void
+menu_show(DBusConnection *conn, struct wl_event_loop *loop, const char *busname,
+          const char *busobj, const char **menucmd)
+{
+	DBusMessage *msg = NULL;
+	DBusPendingCall *pending = NULL;
+	Menu *menu = NULL;
+	char *busname_dup = NULL, *busobj_dup = NULL;
+	dbus_int32_t parentid = 0;
+
+	menu = calloc(1, sizeof(Menu));
+	busname_dup = strdup(busname);
+	busobj_dup = strdup(busobj);
+	if (!menu || !busname_dup || !busobj_dup)
+		goto fail;
+
+	menu->conn = conn;
+	menu->loop = loop;
+	menu->busname = busname_dup;
+	menu->busobj = busobj_dup;
+	menu->menucmd = menucmd;
+
+	msg = dbus_message_new_method_call(menu->busname, menu->busobj,
+	                                   DBUSMENU_IFACE, "AboutToShow");
+	if (!msg)
+		goto fail;
+
+	if (!dbus_message_append_args(msg, DBUS_TYPE_INT32, &parentid,
+	                              DBUS_TYPE_INVALID) ||
+	    !dbus_connection_send_with_reply(menu->conn, msg, &pending, -1) ||
+	    !dbus_pending_call_set_notify(pending, about_to_show_handle, menu,
+	                                  NULL)) {
+		goto fail;
+	}
+
+	dbus_message_unref(msg);
+	return;
+
+fail:
+	if (pending)
+		dbus_pending_call_unref(pending);
+	if (msg)
+		dbus_message_unref(msg);
+	free(menu);
+}
diff --git a/systray/menu.h b/systray/menu.h
new file mode 100644
index 0000000..7f48ada
--- /dev/null
+++ b/systray/menu.h
@@ -0,0 +1,11 @@
+#ifndef MENU_H
+#define MENU_H
+
+#include <dbus/dbus.h>
+#include <wayland-server-core.h>
+
+/* The menu is built on demand and not kept around */
+void menu_show (DBusConnection *conn, struct wl_event_loop *loop,
+                const char *busname, const char *busobj, const char **menucmd);
+
+#endif /* MENU_H */
diff --git a/systray/tray.c b/systray/tray.c
new file mode 100644
index 0000000..7f9b1b0
--- /dev/null
+++ b/systray/tray.c
@@ -0,0 +1,237 @@
+#include "tray.h"
+
+#include "icon.h"
+#include "item.h"
+#include "menu.h"
+#include "watcher.h"
+
+#include <fcft/fcft.h>
+#include <pixman.h>
+#include <wayland-util.h>
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define PIXMAN_COLOR(hex)                        \
+	{ .red = ((hex >> 24) & 0xff) * 0x101,   \
+	  .green = ((hex >> 16) & 0xff) * 0x101, \
+	  .blue = ((hex >> 8) & 0xff) * 0x101,   \
+	  .alpha = (hex & 0xff) * 0x101 }
+
+static Watcher *
+tray_get_watcher(const Tray *tray)
+{
+	if (!tray)
+		return NULL;
+
+	return tray->watcher;
+}
+
+static pixman_image_t *
+createcanvas(int width, int height, int bgcolor)
+{
+	pixman_image_t *src, *dest;
+	pixman_color_t bgcolor_pix = PIXMAN_COLOR(bgcolor);
+
+	dest = pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height, NULL,
+	                                0);
+	src = pixman_image_create_solid_fill(&bgcolor_pix);
+
+	pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dest, 0, 0, 0, 0, 0,
+	                         0, width, height);
+
+	pixman_image_unref(src);
+	return dest;
+}
+
+void
+tray_update(Tray *tray)
+{
+	Item *item;
+	Watcher *watcher;
+	int icon_size, i = 0, canvas_width, canvas_height, n_items, spacing;
+	pixman_image_t *canvas = NULL, *img;
+
+	watcher = tray_get_watcher(tray);
+	n_items = watcher_get_n_items(watcher);
+
+	if (!n_items) {
+		if (tray->image) {
+			pixman_image_unref(tray->image);
+			tray->image = NULL;
+		}
+		tray->cb(tray->monitor);
+		return;
+	}
+
+	icon_size = tray->height;
+	spacing = tray->spacing;
+	canvas_width = n_items * (icon_size + spacing) + spacing;
+	canvas_height = tray->height;
+
+	canvas = createcanvas(canvas_width, canvas_height, tray->scheme[1]);
+	if (!canvas)
+		goto fail;
+
+	wl_list_for_each(item, &watcher->items, link) {
+		int slot_x_start = spacing + i * (icon_size + spacing);
+		int slot_x_end = slot_x_start + icon_size + spacing;
+		int slot_x_width = slot_x_end - slot_x_start;
+
+		int slot_y_start = 0;
+		int slot_y_end = canvas_height;
+		int slot_y_width = slot_y_end - slot_y_start;
+
+		if (item->icon) {
+			/* Real icon */
+			img = item->icon->img;
+			if (resize_image(img, icon_size, icon_size) < 0)
+				goto fail;
+			pixman_image_composite32(PIXMAN_OP_OVER, img, NULL,
+			                         canvas, 0, 0, 0, 0,
+			                         slot_x_start, 0, canvas_width,
+			                         canvas_height);
+
+		} else if (item->appid) {
+			/* Font glyph alpha mask */
+			const struct fcft_glyph *g;
+			int pen_y, pen_x;
+			pixman_color_t fg_color = PIXMAN_COLOR(tray->scheme[0]);
+			pixman_image_t *fg;
+
+			if (item->fallback_icon) {
+				g = item->fallback_icon;
+			} else {
+				g = createfallbackicon(item->appid,
+				                       item->fgcolor,
+				                       tray->font);
+				if (!g)
+					goto fail;
+				item->fallback_icon = g;
+			}
+
+			pen_x = slot_x_start + (slot_x_width - g->width) / 2;
+			pen_y = slot_y_start + (slot_y_width - g->height) / 2;
+
+			fg = pixman_image_create_solid_fill(&fg_color);
+			pixman_image_composite32(PIXMAN_OP_OVER, fg, g->pix,
+			                         canvas, 0, 0, 0, 0, pen_x,
+			                         pen_y, canvas_width,
+			                         canvas_height);
+			pixman_image_unref(fg);
+		}
+		i++;
+	}
+
+	if (tray->image)
+		pixman_image_unref(tray->image);
+	tray->image = canvas;
+	tray->cb(tray->monitor);
+
+	return;
+
+fail:
+	if (canvas)
+		pixman_image_unref(canvas);
+	return;
+}
+
+void
+destroytray(Tray *tray)
+{
+	if (tray->image)
+		pixman_image_unref(tray->image);
+	if (tray->font)
+		fcft_destroy(tray->font);
+	free(tray);
+}
+
+Tray *
+createtray(void *monitor, int height, int spacing, uint32_t *colorscheme,
+           const char **fonts, const char *fontattrs, TrayNotifyCb cb,
+           Watcher *watcher)
+{
+	Tray *tray = NULL;
+	char fontattrs_my[128];
+	struct fcft_font *font = NULL;
+
+	sprintf(fontattrs_my, "%s:%s", fontattrs, "weight:bold");
+
+	tray = calloc(1, sizeof(Tray));
+	font = fcft_from_name(1, fonts, fontattrs_my);
+	if (!tray || !font)
+		goto fail;
+
+	tray->monitor = monitor;
+	tray->height = height;
+	tray->spacing = spacing;
+	tray->scheme = colorscheme;
+	tray->cb = cb;
+	tray->watcher = watcher;
+	tray->font = font;
+
+	return tray;
+
+fail:
+	if (font)
+		fcft_destroy(font);
+	free(tray);
+	return NULL;
+}
+
+int
+tray_get_width(const Tray *tray)
+{
+	if (tray && tray->image)
+		return pixman_image_get_width(tray->image);
+	else
+		return 0;
+}
+
+int
+tray_get_icon_width(const Tray *tray)
+{
+	if (!tray)
+		return 0;
+
+	return tray->height;
+}
+
+void
+tray_rightclicked(Tray *tray, unsigned int index, const char **menucmd)
+{
+	Item *item;
+	Watcher *watcher;
+	unsigned int count = 0;
+
+	watcher = tray_get_watcher(tray);
+
+	wl_list_for_each(item, &watcher->items, link) {
+		if (count == index) {
+			menu_show(watcher->conn, watcher->loop, item->busname,
+			          item->menu_busobj, menucmd);
+			return;
+		}
+		count++;
+	}
+}
+
+void
+tray_leftclicked(Tray *tray, unsigned int index)
+{
+	Item *item;
+	Watcher *watcher;
+	unsigned int count = 0;
+
+	watcher = tray_get_watcher(tray);
+
+	wl_list_for_each(item, &watcher->items, link) {
+		if (count == index) {
+			item_activate(item);
+			return;
+		}
+		count++;
+	}
+}
diff --git a/systray/tray.h b/systray/tray.h
new file mode 100644
index 0000000..af4e5e3
--- /dev/null
+++ b/systray/tray.h
@@ -0,0 +1,37 @@
+#ifndef TRAY_H
+#define TRAY_H
+
+#include "watcher.h"
+
+#include <pixman.h>
+#include <wayland-util.h>
+
+#include <stdint.h>
+
+typedef void (*TrayNotifyCb)(void *data);
+
+typedef struct {
+	pixman_image_t *image;
+	struct fcft_font *font;
+	uint32_t *scheme;
+	TrayNotifyCb cb;
+	Watcher *watcher;
+	void *monitor;
+	int height;
+	int spacing;
+
+	struct wl_list link;
+} Tray;
+
+Tray *createtray (void *monitor, int height, int spacing, uint32_t *colorscheme,
+                  const char **fonts, const char *fontattrs, TrayNotifyCb cb,
+                  Watcher *watcher);
+void destroytray (Tray *tray);
+
+int tray_get_width (const Tray *tray);
+int tray_get_icon_width (const Tray *tray);
+void tray_update (Tray *tray);
+void tray_leftclicked (Tray *tray, unsigned int index);
+void tray_rightclicked (Tray *tray, unsigned int index, const char **menucmd);
+
+#endif /* TRAY_H */
diff --git a/systray/watcher.c b/systray/watcher.c
new file mode 100644
index 0000000..072ab86
--- /dev/null
+++ b/systray/watcher.c
@@ -0,0 +1,549 @@
+#include "watcher.h"
+
+#include "item.h"
+#include "tray.h"
+
+#include <dbus/dbus.h>
+#include <wayland-util.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+// IWYU pragma: no_include "dbus/dbus-protocol.h"
+// IWYU pragma: no_include "dbus/dbus-shared.h"
+
+static const char *const match_rule =
+	"type='signal',"
+	"interface='" DBUS_INTERFACE_DBUS
+	"',"
+	"member='NameOwnerChanged'";
+
+static const char *const snw_xml =
+	"<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
+	" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
+	"<node>\n"
+	"    <interface name=\"" DBUS_INTERFACE_PROPERTIES
+	"\">\n"
+	"        <method name=\"Get\">\n"
+	"            <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
+	"            <arg type=\"s\" name=\"property_name\" direction=\"in\"/>\n"
+	"            <arg type=\"v\" name=\"value\" direction=\"out\"/>\n"
+	"        </method>\n"
+	"        <method name=\"GetAll\">\n"
+	"            <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
+	"            <arg type=\"a{sv}\" name=\"properties\" direction=\"out\"/>\n"
+	"        </method>\n"
+	"        <method name=\"Set\">\n"
+	"            <arg type=\"s\" name=\"interface_name\" direction=\"in\"/>\n"
+	"            <arg type=\"s\" name=\"property_name\" direction=\"in\"/>\n"
+	"            <arg type=\"v\" name=\"value\" direction=\"in\"/>\n"
+	"        </method>\n"
+	"        <signal name=\"PropertiesChanged\">\n"
+	"            <arg type=\"s\" name=\"interface_name\"/>\n"
+	"            <arg type=\"a{sv}\" name=\"changed_properties\"/>\n"
+	"            <arg type=\"as\" name=\"invalidated_properties\"/>\n"
+	"        </signal>\n"
+	"    </interface>\n"
+	"    <interface name=\"" DBUS_INTERFACE_INTROSPECTABLE
+	"\">\n"
+	"        <method name=\"Introspect\">\n"
+	"            <arg type=\"s\" name=\"xml_data\" direction=\"out\"/>\n"
+	"        </method>\n"
+	"    </interface>\n"
+	"    <interface name=\"" DBUS_INTERFACE_PEER
+	"\">\n"
+	"        <method name=\"Ping\"/>\n"
+	"        <method name=\"GetMachineId\">\n"
+	"            <arg type=\"s\" name=\"machine_uuid\" direction=\"out\"/>\n"
+	"        </method>\n"
+	"    </interface>\n"
+	"    <interface name=\"" SNW_IFACE
+	"\">\n"
+	"        <!-- methods -->\n"
+	"        <method name=\"RegisterStatusNotifierItem\">\n"
+	"            <arg name=\"service\" type=\"s\" direction=\"in\" />\n"
+	"        </method>\n"
+	"        <!-- properties -->\n"
+	"        <property name=\"IsStatusNotifierHostRegistered\" type=\"b\" access=\"read\" />\n"
+	"        <property name=\"ProtocolVersion\" type=\"i\" access=\"read\" />\n"
+	"        <property name=\"RegisteredStatusNotifierItems\" type=\"as\" access=\"read\" />\n"
+	"        <!-- signals -->\n"
+	"        <signal name=\"StatusNotifierHostRegistered\">\n"
+	"        </signal>\n"
+	"    </interface>\n"
+	"</node>\n";
+
+static void
+unregister_item(Watcher *watcher, Item *item)
+{
+	wl_list_remove(&item->link);
+	destroyitem(item);
+
+	watcher_update_trays(watcher);
+}
+
+static Item *
+item_name_to_ptr(const Watcher *watcher, const char *busname)
+{
+	Item *item;
+
+	wl_list_for_each(item, &watcher->items, link) {
+		if (!item || !item->busname)
+			return NULL;
+		if (strcmp(item->busname, busname) == 0)
+			return item;
+	}
+
+	return NULL;
+}
+
+static DBusHandlerResult
+handle_nameowner_changed(Watcher *watcher, DBusConnection *conn,
+                         DBusMessage *msg)
+{
+	char *name, *old_owner, *new_owner;
+	Item *item;
+
+	if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
+	                           DBUS_TYPE_STRING, &old_owner,
+	                           DBUS_TYPE_STRING, &new_owner,
+	                           DBUS_TYPE_INVALID)) {
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	if (*new_owner != '\0' || *name == '\0')
+		return DBUS_HANDLER_RESULT_HANDLED;
+
+	item = item_name_to_ptr(watcher, name);
+	if (!item)
+		return DBUS_HANDLER_RESULT_HANDLED;
+
+	unregister_item(watcher, item);
+
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+filter_bus(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	Watcher *watcher = data;
+
+	if (dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS,
+	                           "NameOwnerChanged"))
+		return handle_nameowner_changed(watcher, conn, msg);
+
+	else
+		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static DBusHandlerResult
+respond_register_item(Watcher *watcher, DBusConnection *conn, DBusMessage *msg)
+{
+	DBusHandlerResult res = DBUS_HANDLER_RESULT_HANDLED;
+
+	DBusMessage *reply = NULL;
+	Item *item;
+	const char *sender, *param, *busobj, *registree_name;
+
+	if (!(sender = dbus_message_get_sender(msg)) ||
+	    !dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &param,
+	                           DBUS_TYPE_INVALID)) {
+		reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS,
+		                               "Malformed message");
+		goto send;
+	}
+
+	switch (*param) {
+	case '/':
+		registree_name = sender;
+		busobj = param;
+		break;
+	case ':':
+		registree_name = param;
+		busobj = SNI_OPATH;
+		break;
+	default:
+		reply = dbus_message_new_error_printf(msg,
+		                                      DBUS_ERROR_INVALID_ARGS,
+		                                      "Bad argument: \"%s\"",
+		                                      param);
+		goto send;
+	}
+
+	if (*registree_name != ':' ||
+	    !dbus_validate_bus_name(registree_name, NULL)) {
+		reply = dbus_message_new_error_printf(msg,
+		                                      DBUS_ERROR_INVALID_ARGS,
+		                                      "Invalid busname %s",
+		                                      registree_name);
+		goto send;
+	}
+
+	if (item_name_to_ptr(watcher, registree_name)) {
+		reply = dbus_message_new_error_printf(msg,
+		                                      DBUS_ERROR_INVALID_ARGS,
+		                                      "%s already tracked",
+		                                      registree_name);
+		goto send;
+	}
+
+	item = createitem(registree_name, busobj, watcher);
+	wl_list_insert(&watcher->items, &item->link);
+	watcher_update_trays(watcher);
+
+	reply = dbus_message_new_method_return(msg);
+
+send:
+	if (!reply || !dbus_connection_send(conn, reply, NULL))
+		res = DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+	if (reply)
+		dbus_message_unref(reply);
+	return res;
+}
+
+static int
+get_registered_items(const Watcher *watcher, DBusMessageIter *iter)
+{
+	DBusMessageIter names = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	Item *item;
+	int r;
+
+	if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+	                                      DBUS_TYPE_STRING_AS_STRING,
+	                                      &names)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	wl_list_for_each(item, &watcher->items, link) {
+		if (!dbus_message_iter_append_basic(&names, DBUS_TYPE_STRING,
+		                                    &item->busname)) {
+			r = -ENOMEM;
+			goto fail;
+		}
+	}
+
+	dbus_message_iter_close_container(iter, &names);
+	return 0;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(iter, &names);
+	return r;
+}
+
+static int
+get_registered_items_variant(const Watcher *watcher, DBusMessageIter *iter)
+{
+	DBusMessageIter variant = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	int r;
+
+	if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "as",
+	                                      &variant) ||
+	    get_registered_items(watcher, &variant) < 0) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_iter_close_container(iter, &variant);
+	return 0;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(iter, &variant);
+	return r;
+}
+
+static int
+get_isregistered(DBusMessageIter *iter)
+{
+	DBusMessageIter variant = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	dbus_bool_t is_registered = TRUE;
+	int r;
+
+	if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+	                                      DBUS_TYPE_BOOLEAN_AS_STRING,
+	                                      &variant) ||
+	    !dbus_message_iter_append_basic(&variant, DBUS_TYPE_BOOLEAN,
+	                                    &is_registered)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_iter_close_container(iter, &variant);
+	return 0;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(iter, &variant);
+	return r;
+}
+
+static int
+get_version(DBusMessageIter *iter)
+{
+	DBusMessageIter variant = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	dbus_int32_t protovers = 0;
+	int r;
+
+	if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+	                                      DBUS_TYPE_INT32_AS_STRING,
+	                                      &variant) ||
+	    !dbus_message_iter_append_basic(&variant, DBUS_TYPE_INT32,
+	                                    &protovers)) {
+		r = -ENOMEM;
+		goto fail;
+	}
+
+	dbus_message_iter_close_container(iter, &variant);
+	return 0;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(iter, &variant);
+	return r;
+}
+
+static DBusHandlerResult
+respond_get_prop(Watcher *watcher, DBusConnection *conn, DBusMessage *msg)
+{
+	DBusError err = DBUS_ERROR_INIT;
+	DBusMessage *reply = NULL;
+	DBusMessageIter iter = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	const char *iface, *prop;
+
+	if (!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &iface,
+	                           DBUS_TYPE_STRING, &prop,
+	                           DBUS_TYPE_INVALID)) {
+		reply = dbus_message_new_error(msg, err.name, err.message);
+		dbus_error_free(&err);
+		goto send;
+	}
+
+	if (strcmp(iface, SNW_IFACE) != 0) {
+		reply = dbus_message_new_error_printf(
+			msg, DBUS_ERROR_UNKNOWN_INTERFACE,
+			"Unknown interface \"%s\"", iface);
+		goto send;
+	}
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		goto fail;
+
+	if (strcmp(prop, "ProtocolVersion") == 0) {
+		dbus_message_iter_init_append(reply, &iter);
+		if (get_version(&iter) < 0)
+			goto fail;
+
+	} else if (strcmp(prop, "IsStatusNotifierHostRegistered") == 0) {
+		dbus_message_iter_init_append(reply, &iter);
+		if (get_isregistered(&iter) < 0)
+			goto fail;
+
+	} else if (strcmp(prop, "RegisteredStatusNotifierItems") == 0) {
+		dbus_message_iter_init_append(reply, &iter);
+		if (get_registered_items_variant(watcher, &iter) < 0)
+			goto fail;
+
+	} else {
+		dbus_message_unref(reply);
+		reply = dbus_message_new_error_printf(
+			reply, DBUS_ERROR_UNKNOWN_PROPERTY,
+			"Property \"%s\" does not exist", prop);
+	}
+
+send:
+	if (!reply || !dbus_connection_send(conn, reply, NULL))
+		goto fail;
+
+	if (reply)
+		dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+
+fail:
+	if (reply)
+		dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+}
+
+static DBusHandlerResult
+respond_all_props(Watcher *watcher, DBusConnection *conn, DBusMessage *msg)
+{
+	DBusMessage *reply = NULL;
+	DBusMessageIter array = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	DBusMessageIter dict = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	DBusMessageIter iter = DBUS_MESSAGE_ITER_INIT_CLOSED;
+	const char *prop;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		goto fail;
+	dbus_message_iter_init_append(reply, &iter);
+
+	if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}",
+	                                      &array))
+		goto fail;
+
+	prop = "ProtocolVersion";
+	if (!dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY,
+	                                      NULL, &dict) ||
+	    !dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &prop) ||
+	    get_version(&dict) < 0 ||
+	    !dbus_message_iter_close_container(&array, &dict)) {
+		goto fail;
+	}
+
+	prop = "IsStatusNotifierHostRegistered";
+	if (!dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY,
+	                                      NULL, &dict) ||
+	    !dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &prop) ||
+	    get_isregistered(&dict) < 0 ||
+	    !dbus_message_iter_close_container(&array, &dict)) {
+		goto fail;
+	}
+
+	prop = "RegisteredStatusNotifierItems";
+	if (!dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY,
+	                                      NULL, &dict) ||
+	    !dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &prop) ||
+	    get_registered_items_variant(watcher, &dict) < 0 ||
+	    !dbus_message_iter_close_container(&array, &dict)) {
+		goto fail;
+	}
+
+	if (!dbus_message_iter_close_container(&iter, &array) ||
+	    !dbus_connection_send(conn, reply, NULL)) {
+		goto fail;
+	}
+
+	dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+
+fail:
+	dbus_message_iter_abandon_container_if_open(&array, &dict);
+	dbus_message_iter_abandon_container_if_open(&iter, &array);
+	if (reply)
+		dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+}
+
+static DBusHandlerResult
+respond_introspect(DBusConnection *conn, DBusMessage *msg)
+{
+	DBusMessage *reply = NULL;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		goto fail;
+
+	if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &snw_xml,
+	                              DBUS_TYPE_INVALID) ||
+	    !dbus_connection_send(conn, reply, NULL)) {
+		goto fail;
+	}
+
+	dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+
+fail:
+	if (reply)
+		dbus_message_unref(reply);
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+}
+
+static DBusHandlerResult
+snw_message_handler(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	Watcher *watcher = data;
+
+	if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE,
+	                                "Introspect"))
+		return respond_introspect(conn, msg);
+
+	else if (dbus_message_is_method_call(msg, DBUS_INTERFACE_PROPERTIES,
+	                                     "GetAll"))
+		return respond_all_props(watcher, conn, msg);
+
+	else if (dbus_message_is_method_call(msg, DBUS_INTERFACE_PROPERTIES,
+	                                     "Get"))
+		return respond_get_prop(watcher, conn, msg);
+
+	else if (dbus_message_is_method_call(msg, SNW_IFACE,
+	                                     "RegisterStatusNotifierItem"))
+		return respond_register_item(watcher, conn, msg);
+
+	else
+		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static const DBusObjectPathVTable snw_vtable = { .message_function =
+	                                                 snw_message_handler };
+
+int
+watcher_start(Watcher *watcher, DBusConnection *conn,
+              struct wl_event_loop *loop)
+{
+	DBusError err = DBUS_ERROR_INIT;
+	int r;
+
+	wl_list_init(&watcher->items);
+	wl_list_init(&watcher->trays);
+	watcher->conn = conn;
+	watcher->loop = loop;
+
+	r = dbus_bus_request_name(conn, SNW_NAME,
+	                          DBUS_NAME_FLAG_REPLACE_EXISTING, NULL);
+	if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
+		goto fail;
+
+	if (!dbus_connection_add_filter(conn, filter_bus, watcher, NULL)) {
+		dbus_bus_release_name(conn, SNW_NAME, NULL);
+		goto fail;
+	}
+
+	dbus_bus_add_match(conn, match_rule, &err);
+	if (dbus_error_is_set(&err)) {
+		dbus_connection_remove_filter(conn, filter_bus, watcher);
+		dbus_bus_release_name(conn, SNW_NAME, NULL);
+		goto fail;
+	}
+
+	if (!dbus_connection_register_object_path(conn, SNW_OPATH, &snw_vtable,
+	                                          watcher)) {
+		dbus_bus_remove_match(conn, match_rule, NULL);
+		dbus_connection_remove_filter(conn, filter_bus, watcher);
+		dbus_bus_release_name(conn, SNW_NAME, NULL);
+		goto fail;
+	}
+
+	dbus_error_free(&err);
+	return 0;
+
+fail:
+	fprintf(stderr, "Couldn't start watcher, systray not available\n");
+	dbus_error_free(&err);
+	return -1;
+}
+
+void
+watcher_stop(Watcher *watcher)
+{
+	dbus_connection_unregister_object_path(watcher->conn, SNW_OPATH);
+	dbus_bus_remove_match(watcher->conn, match_rule, NULL);
+	dbus_connection_remove_filter(watcher->conn, filter_bus, watcher);
+	dbus_bus_release_name(watcher->conn, SNW_NAME, NULL);
+}
+
+int
+watcher_get_n_items(const Watcher *watcher)
+{
+	return wl_list_length(&watcher->items);
+}
+
+void
+watcher_update_trays(Watcher *watcher)
+{
+	Tray *tray;
+
+	wl_list_for_each(tray, &watcher->trays, link)
+		tray_update(tray);
+}
diff --git a/systray/watcher.h b/systray/watcher.h
new file mode 100644
index 0000000..0178587
--- /dev/null
+++ b/systray/watcher.h
@@ -0,0 +1,34 @@
+#ifndef WATCHER_H
+#define WATCHER_H
+
+#include <dbus/dbus.h>
+#include <wayland-server-core.h>
+#include <wayland-util.h>
+
+/*
+ * The FDO spec says "org.freedesktop.StatusNotifierWatcher"[1],
+ * but both the client libraries[2,3] actually use "org.kde.StatusNotifierWatcher"
+ *
+ * [1] https://www.freedesktop.org/wiki/Specifications/StatusNotifierItem/
+ * [2] https://github.com/AyatanaIndicators/libayatana-appindicator-glib
+ * [3] https://invent.kde.org/frameworks/kstatusnotifieritem
+ */
+#define SNW_NAME "org.kde.StatusNotifierWatcher"
+#define SNW_OPATH "/StatusNotifierWatcher"
+#define SNW_IFACE "org.kde.StatusNotifierWatcher"
+
+typedef struct {
+	struct wl_list items;
+	struct wl_list trays;
+	struct wl_event_loop *loop;
+	DBusConnection *conn;
+} Watcher;
+
+int watcher_start (Watcher *watcher, DBusConnection *conn,
+                   struct wl_event_loop *loop);
+void watcher_stop (Watcher *watcher);
+
+int watcher_get_n_items (const Watcher *watcher);
+void watcher_update_trays (Watcher *watcher);
+
+#endif /* WATCHER_H */