jachym/dwl-patches
1
0
Fork 0
mirror of https://codeberg.org/dwl/dwl-patches.git synced 2025-10-31 12:04:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
dwl-patches/patches/bar-systray/bar-systray-0.7.patch

3024 lines
78 KiB
Diff
Raw Blame History

From cf228147250f4616d150fbe5276088c5f9969bba Mon Sep 17 00:00:00 2001
From: vetu104 <vetu104@proton.me>
Date: Sat, 29 Mar 2025 19:22:37 +0200
Subject: [PATCH] Add a system tray next to sewn's bar
---
Makefile | 23 +-
config.def.h | 5 +
dbus.c | 242 +++++++++++++++
dbus.h | 10 +
dwl.c | 107 ++++++-
systray/helpers.c | 43 +++
systray/helpers.h | 12 +
systray/icon.c | 149 +++++++++
systray/icon.h | 26 ++
systray/item.c | 403 ++++++++++++++++++++++++
systray/item.h | 46 +++
systray/menu.c | 757 ++++++++++++++++++++++++++++++++++++++++++++++
systray/menu.h | 11 +
systray/tray.c | 237 +++++++++++++++
systray/tray.h | 37 +++
systray/watcher.c | 551 +++++++++++++++++++++++++++++++++
systray/watcher.h | 35 +++
17 files changed, 2681 insertions(+), 13 deletions(-)
create mode 100644 dbus.c
create mode 100644 dbus.h
create mode 100644 systray/helpers.c
create mode 100644 systray/helpers.h
create mode 100644 systray/icon.c
create mode 100644 systray/icon.h
create mode 100644 systray/item.c
create mode 100644 systray/item.h
create mode 100644 systray/menu.c
create mode 100644 systray/menu.h
create mode 100644 systray/tray.c
create mode 100644 systray/tray.h
create mode 100644 systray/watcher.c
create mode 100644 systray/watcher.h
diff --git a/Makefile b/Makefile
index 9bc67db..9d50189 100644
--- a/Makefile
+++ b/Makefile
@@ -12,17 +12,28 @@ DWLDEVCFLAGS = -g -pedantic -Wall -Wextra -Wdeclaration-after-statement \
-Wfloat-conversion
# CFLAGS / LDFLAGS
-PKGS = wlroots-0.18 wayland-server xkbcommon libinput pixman-1 fcft $(XLIBS)
+PKGS = wlroots-0.18 wayland-server xkbcommon libinput pixman-1 fcft $(XLIBS) dbus-1
DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CFLAGS)
LDLIBS = `$(PKG_CONFIG) --libs $(PKGS)` -lm $(LIBS)
+TRAYOBJS = systray/watcher.o systray/tray.o systray/item.o systray/icon.o systray/menu.o systray/helpers.o
+TRAYDEPS = systray/watcher.h systray/tray.h systray/item.h systray/icon.h systray/menu.h systray/helpers.h
+
all: dwl
-dwl: dwl.o util.o
- $(CC) dwl.o util.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
-dwl.o: dwl.c client.h config.h config.mk cursor-shape-v1-protocol.h \
+dwl: dwl.o util.o dbus.o $(TRAYOBJS) $(TRAYDEPS)
+ $(CC) dwl.o util.o dbus.o $(TRAYOBJS) $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
+dwl.o: dwl.c client.h dbus.h config.h config.mk cursor-shape-v1-protocol.h \
pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h \
- wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h
+ wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h \
+ $(TRAYDEPS)
util.o: util.c util.h
+dbus.o: dbus.c dbus.h
+systray/watcher.o: systray/watcher.c $(TRAYDEPS)
+systray/tray.o: systray/tray.c $(TRAYDEPS)
+systray/item.o: systray/item.c $(TRAYDEPS)
+systray/icon.o: systray/icon.c $(TRAYDEPS)
+systray/menu.o: systray/menu.c $(TRAYDEPS)
+systray/helpers.o: systray/helpers.c $(TRAYDEPS)
# wayland-scanner is a tool which generates C headers and rigging for Wayland
# protocols, which are specified in XML. wlroots requires you to rig these up
@@ -49,7 +60,7 @@ xdg-shell-protocol.h:
config.h:
cp config.def.h $@
clean:
- rm -f dwl *.o *-protocol.h
+ rm -f dwl *.o *-protocol.h systray/*.o
dist: clean
mkdir -p dwl-$(VERSION)
diff --git a/config.def.h b/config.def.h
index 5d1dc2b..451643e 100644
--- a/config.def.h
+++ b/config.def.h
@@ -7,6 +7,8 @@
static const int sloppyfocus = 1; /* focus follows mouse */
static const int bypass_surface_visibility = 0; /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible */
static const unsigned int borderpx = 1; /* border pixel of windows */
+static const unsigned int systrayspacing = 2; /* systray spacing */
+static const int showsystray = 1; /* 0 means no systray */
static const int showbar = 1; /* 0 means no bar */
static const int topbar = 1; /* 0 means bottom bar */
static const char *fonts[] = {"monospace:size=10"};
@@ -127,6 +129,7 @@ static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TA
/* commands */
static const char *termcmd[] = { "foot", NULL };
static const char *menucmd[] = { "wmenu-run", NULL };
+static const char *dmenucmd[] = { "wmenu", NULL };
static const Key keys[] = {
/* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */
@@ -188,4 +191,6 @@ static const Button buttons[] = {
{ ClkTagBar, 0, BTN_RIGHT, toggleview, {0} },
{ ClkTagBar, MODKEY, BTN_LEFT, tag, {0} },
{ ClkTagBar, MODKEY, BTN_RIGHT, toggletag, {0} },
+ { ClkTray, 0, BTN_LEFT, trayactivate, {0} },
+ { ClkTray, 0, BTN_RIGHT, traymenu, {0} },
};
diff --git a/dbus.c b/dbus.c
new file mode 100644
index 0000000..125312c
--- /dev/null
+++ b/dbus.c
@@ -0,0 +1,242 @@
+#include "dbus.h"
+
+#include "util.h"
+
+#include <dbus/dbus.h>
+#include <stdlib.h>
+#include <wayland-server-core.h>
+
+#include <fcntl.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+
+static void
+close_pipe(void *data)
+{
+ int *pipefd = data;
+
+ close(pipefd[0]);
+ close(pipefd[1]);
+ free(pipefd);
+}
+
+static int
+dwl_dbus_dispatch(int fd, unsigned int mask, void *data)
+{
+ DBusConnection *conn = data;
+
+ int pending;
+ DBusDispatchStatus oldstatus, newstatus;
+
+ oldstatus = dbus_connection_get_dispatch_status(conn);
+ newstatus = dbus_connection_dispatch(conn);
+
+ /* Don't clear pending flag if status didn't change */
+ if (oldstatus == newstatus)
+ return 0;
+
+ if (read(fd, &pending, sizeof(int)) < 0) {
+ perror("read");
+ die("Error in dbus dispatch");
+ }
+
+ return 0;
+}
+
+static int
+dwl_dbus_watch_handle(int fd, uint32_t mask, void *data)
+{
+ DBusWatch *watch = data;
+
+ uint32_t flags = 0;
+
+ if (!dbus_watch_get_enabled(watch))
+ return 0;
+
+ if (mask & WL_EVENT_READABLE)
+ flags |= DBUS_WATCH_READABLE;
+ if (mask & WL_EVENT_WRITABLE)
+ flags |= DBUS_WATCH_WRITABLE;
+ if (mask & WL_EVENT_HANGUP)
+ flags |= DBUS_WATCH_HANGUP;
+ if (mask & WL_EVENT_ERROR)
+ flags |= DBUS_WATCH_ERROR;
+
+ dbus_watch_handle(watch, flags);
+
+ return 0;
+}
+
+static dbus_bool_t
+dwl_dbus_add_watch(DBusWatch *watch, void *data)
+{
+ struct wl_event_loop *loop = data;
+
+ int fd;
+ struct wl_event_source *watch_source;
+ uint32_t mask = 0, flags;
+
+ if (!dbus_watch_get_enabled(watch))
+ return TRUE;
+
+ flags = dbus_watch_get_flags(watch);
+ if (flags & DBUS_WATCH_READABLE)
+ mask |= WL_EVENT_READABLE;
+ if (flags & DBUS_WATCH_WRITABLE)
+ mask |= WL_EVENT_WRITABLE;
+
+ fd = dbus_watch_get_unix_fd(watch);
+ watch_source = wl_event_loop_add_fd(loop, fd, mask,
+ dwl_dbus_watch_handle, watch);
+
+ dbus_watch_set_data(watch, watch_source, NULL);
+
+ return TRUE;
+}
+
+static void
+dwl_dbus_remove_watch(DBusWatch *watch, void *data)
+{
+ struct wl_event_source *watch_source = dbus_watch_get_data(watch);
+
+ if (watch_source)
+ wl_event_source_remove(watch_source);
+}
+
+static int
+dwl_dbus_timeout_handle(void *data)
+{
+ DBusTimeout *timeout = data;
+
+ if (dbus_timeout_get_enabled(timeout))
+ dbus_timeout_handle(timeout);
+
+ return 0;
+}
+
+static dbus_bool_t
+dwl_dbus_add_timeout(DBusTimeout *timeout, void *data)
+{
+ struct wl_event_loop *loop = data;
+
+ int r, interval;
+ struct wl_event_source *timeout_source;
+
+ if (!dbus_timeout_get_enabled(timeout))
+ return TRUE;
+
+ interval = dbus_timeout_get_interval(timeout);
+
+ timeout_source =
+ wl_event_loop_add_timer(loop, dwl_dbus_timeout_handle, timeout);
+
+ r = wl_event_source_timer_update(timeout_source, interval);
+ if (r < 0) {
+ wl_event_source_remove(timeout_source);
+ return FALSE;
+ }
+
+ dbus_timeout_set_data(timeout, timeout_source, NULL);
+
+ return TRUE;
+}
+
+static void
+dwl_dbus_remove_timeout(DBusTimeout *timeout, void *data)
+{
+ struct wl_event_source *timeout_source;
+
+ timeout_source = dbus_timeout_get_data(timeout);
+
+ if (timeout_source) {
+ wl_event_source_timer_update(timeout_source, 0);
+ wl_event_source_remove(timeout_source);
+ }
+}
+
+static void
+dwl_dbus_dispatch_status(DBusConnection *conn, DBusDispatchStatus status,
+ void *data)
+{
+ int *pipefd = data;
+
+ if (status != DBUS_DISPATCH_COMPLETE) {
+ int pending = 1;
+ if (write(pipefd[1], &pending, sizeof(int)) < 0) {
+ perror("write");
+ die("Error in dispatch status");
+ }
+ }
+}
+
+struct wl_event_source *
+startbus(DBusConnection *conn, struct wl_event_loop *loop)
+{
+ int *pipefd;
+ int pending = 1, flags;
+ struct wl_event_source *bus_source = NULL;
+
+ pipefd = ecalloc(2, sizeof(int));
+
+ /*
+ * Libdbus forbids calling dbus_connection_dipatch from the
+ * DBusDispatchStatusFunction directly. Notify the event loop of
+ * updates via a self-pipe.
+ */
+ if (pipe(pipefd) < 0)
+ goto fail;
+ if (((flags = fcntl(pipefd[0], F_GETFD)) < 0) ||
+ fcntl(pipefd[0], F_SETFD, flags | FD_CLOEXEC) < 0 ||
+ ((flags = fcntl(pipefd[1], F_GETFD)) < 0) ||
+ fcntl(pipefd[1], F_SETFD, flags | FD_CLOEXEC) < 0) {
+ goto fail;
+ }
+
+ dbus_connection_set_exit_on_disconnect(conn, FALSE);
+
+ bus_source = wl_event_loop_add_fd(loop, pipefd[0], WL_EVENT_READABLE,
+ dwl_dbus_dispatch, conn);
+ if (!bus_source)
+ goto fail;
+
+ dbus_connection_set_dispatch_status_function(conn,
+ dwl_dbus_dispatch_status,
+ pipefd, close_pipe);
+ if (!dbus_connection_set_watch_functions(conn, dwl_dbus_add_watch,
+ dwl_dbus_remove_watch, NULL,
+ loop, NULL)) {
+ goto fail;
+ }
+ if (!dbus_connection_set_timeout_functions(conn, dwl_dbus_add_timeout,
+ dwl_dbus_remove_timeout,
+ NULL, loop, NULL)) {
+ goto fail;
+ }
+ if (dbus_connection_get_dispatch_status(conn) != DBUS_DISPATCH_COMPLETE)
+ if (write(pipefd[1], &pending, sizeof(int)) < 0)
+ goto fail;
+
+ return bus_source;
+
+fail:
+ if (bus_source)
+ wl_event_source_remove(bus_source);
+ dbus_connection_set_timeout_functions(conn, NULL, NULL, NULL, NULL,
+ NULL);
+ dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL);
+ dbus_connection_set_dispatch_status_function(conn, NULL, NULL, NULL);
+
+ return NULL;
+}
+
+void
+stopbus(DBusConnection *conn, struct wl_event_source *bus_source)
+{
+ wl_event_source_remove(bus_source);
+ dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL);
+ dbus_connection_set_timeout_functions(conn, NULL, NULL, NULL, NULL,
+ NULL);
+ dbus_connection_set_dispatch_status_function(conn, NULL, NULL, NULL);
+}
diff --git a/dbus.h b/dbus.h
new file mode 100644
index 0000000..b374b98
--- /dev/null
+++ b/dbus.h
@@ -0,0 +1,10 @@
+#ifndef DWLDBUS_H
+#define DWLDBUS_H
+
+#include <dbus/dbus.h>
+#include <wayland-server-core.h>
+
+struct wl_event_source* startbus (DBusConnection *conn, struct wl_event_loop *loop);
+void stopbus (DBusConnection *conn, struct wl_event_source *bus_source);
+
+#endif /* DWLDBUS_H */
diff --git a/dwl.c b/dwl.c
index ece537a..7753ef6 100644
--- a/dwl.c
+++ b/dwl.c
@@ -1,6 +1,7 @@
/*
* See LICENSE file for copyright and license details.
*/
+#include <dbus/dbus.h>
#include <getopt.h>
#include <libinput.h>
#include <linux/input-event-codes.h>
@@ -71,6 +72,9 @@
#include "util.h"
#include "drwl.h"
+#include "dbus.h"
+#include "systray/tray.h"
+#include "systray/watcher.h"
/* macros */
#define MAX(A, B) ((A) > (B) ? (A) : (B))
@@ -89,7 +93,7 @@ enum { SchemeNorm, SchemeSel, SchemeUrg }; /* color schemes */
enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */
enum { XDGShell, LayerShell, X11 }; /* client types */
enum { LyrBg, LyrBottom, LyrTile, LyrFloat, LyrTop, LyrFS, LyrOverlay, LyrBlock, NUM_LAYERS }; /* scene layers */
-enum { ClkTagBar, ClkLtSymbol, ClkStatus, ClkTitle, ClkClient, ClkRoot }; /* clicks */
+enum { ClkTagBar, ClkLtSymbol, ClkStatus, ClkTitle, ClkClient, ClkRoot, ClkTray }; /* clicks */
#ifdef XWAYLAND
enum { NetWMWindowTypeDialog, NetWMWindowTypeSplash, NetWMWindowTypeToolbar,
NetWMWindowTypeUtility, NetLast }; /* EWMH atoms */
@@ -218,6 +222,7 @@ struct Monitor {
int real_width, real_height; /* non-scaled */
float scale;
} b; /* bar area */
+ Tray *tray;
struct wlr_box w; /* window area, layout-relative */
struct wl_list layers[4]; /* LayerSurface.link */
const Layout *lt[2];
@@ -376,6 +381,9 @@ static void togglefloating(const Arg *arg);
static void togglefullscreen(const Arg *arg);
static void toggletag(const Arg *arg);
static void toggleview(const Arg *arg);
+static void trayactivate(const Arg *arg);
+static void traymenu(const Arg *arg);
+static void traynotify(void *data);
static void unlocksession(struct wl_listener *listener, void *data);
static void unmaplayersurfacenotify(struct wl_listener *listener, void *data);
static void unmapnotify(struct wl_listener *listener, void *data);
@@ -451,6 +459,10 @@ static Monitor *selmon;
static char stext[256];
static struct wl_event_source *status_event_source;
+static DBusConnection *bus_conn;
+static struct wl_event_source *bus_source;
+static Watcher watcher = {.running = 0};
+
static const struct wlr_buffer_impl buffer_impl = {
.destroy = bufdestroy,
.begin_data_ptr_access = bufdatabegin,
@@ -721,8 +733,8 @@ bufrelease(struct wl_listener *listener, void *data)
void
buttonpress(struct wl_listener *listener, void *data)
{
- unsigned int i = 0, x = 0;
- double cx;
+ unsigned int i = 0, x = 0, ti = 0;
+ double cx, tx = 0;
unsigned int click;
struct wlr_pointer_button_event *event = data;
struct wlr_keyboard *keyboard;
@@ -732,6 +744,7 @@ buttonpress(struct wl_listener *listener, void *data)
Arg arg = {0};
Client *c;
const Button *b;
+ int traywidth;
wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
@@ -751,6 +764,8 @@ buttonpress(struct wl_listener *listener, void *data)
(node = wlr_scene_node_at(&layers[LyrBottom]->node, cursor->x, cursor->y, NULL, NULL)) &&
(buffer = wlr_scene_buffer_from_node(node)) && buffer == selmon->scene_buffer) {
cx = (cursor->x - selmon->m.x) * selmon->wlr_output->scale;
+ traywidth = tray_get_width(selmon->tray);
+
do
x += TEXTW(selmon, tags[i]);
while (cx >= x && ++i < LENGTH(tags));
@@ -759,8 +774,16 @@ buttonpress(struct wl_listener *listener, void *data)
arg.ui = 1 << i;
} else if (cx < x + TEXTW(selmon, selmon->ltsymbol))
click = ClkLtSymbol;
- else if (cx > selmon->b.width - (TEXTW(selmon, stext) - selmon->lrpad + 2)) {
+ else if (cx > selmon->b.width - (TEXTW(selmon, stext) - selmon->lrpad + 2) && cx < selmon->b.width - traywidth) {
click = ClkStatus;
+ } else if (cx > selmon->b.width - (TEXTW(selmon, stext) - selmon->lrpad + 2)) {
+ unsigned int tray_n_items = watcher_get_n_items(&watcher);
+ tx = selmon->b.width - traywidth;
+ do
+ tx += tray_n_items ? (int)(traywidth / tray_n_items) : 0;
+ while (cx >= tx && ++ti < tray_n_items);
+ click = ClkTray;
+ arg.ui = ti;
} else
click = ClkTitle;
}
@@ -774,7 +797,12 @@ buttonpress(struct wl_listener *listener, void *data)
mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
for (b = buttons; b < END(buttons); b++) {
if (CLEANMASK(mods) == CLEANMASK(b->mod) && event->button == b->button && click == b->click && b->func) {
- b->func(click == ClkTagBar && b->arg.i == 0 ? &arg : &b->arg);
+ if (click == ClkTagBar && b->arg.i == 0)
+ b->func(&arg);
+ else if (click == ClkTray && b->arg.i == 0)
+ b->func(&arg);
+ else
+ b->func(&b->arg);
return;
}
}
@@ -840,6 +868,14 @@ cleanup(void)
destroykeyboardgroup(&kb_group->destroy, NULL);
+ if (watcher.running)
+ watcher_stop(&watcher);
+
+ if (showbar && showsystray) {
+ stopbus(bus_conn, bus_source);
+ dbus_connection_unref(bus_conn);
+ }
+
/* If it's not destroyed manually it will cause a use-after-free of wlr_seat.
* Destroy it until it's fixed in the wlroots side */
wlr_backend_destroy(backend);
@@ -868,6 +904,9 @@ cleanupmon(struct wl_listener *listener, void *data)
for (i = 0; i < LENGTH(m->pool); i++)
wlr_buffer_drop(&m->pool[i]->base);
+ if (showsystray)
+ destroytray(m->tray);
+
drwl_setimage(m->drw, NULL);
drwl_destroy(m->drw);
@@ -1506,6 +1545,7 @@ dirtomon(enum wlr_direction dir)
void
drawbar(Monitor *m)
{
+ int traywidth = 0;
int x, w, tw = 0;
int boxs = m->drw->font->height / 9;
int boxw = m->drw->font->height / 6 + 2;
@@ -1518,11 +1558,13 @@ drawbar(Monitor *m)
if (!(buf = bufmon(m)))
return;
+ traywidth = tray_get_width(m->tray);
+
/* draw status first so it can be overdrawn by tags later */
if (m == selmon) { /* status is only drawn on selected monitor */
drwl_setscheme(m->drw, colors[SchemeNorm]);
tw = TEXTW(m, stext) - m->lrpad + 2; /* 2px right padding */
- drwl_text(m->drw, m->b.width - tw, 0, tw, m->b.height, 0, stext, 0);
+ drwl_text(m->drw, m->b.width - (tw + traywidth), 0, tw, m->b.height, 0, stext, 0);
}
wl_list_for_each(c, &clients, link) {
@@ -1548,7 +1590,7 @@ drawbar(Monitor *m)
drwl_setscheme(m->drw, colors[SchemeNorm]);
x = drwl_text(m->drw, x, 0, w, m->b.height, m->lrpad / 2, m->ltsymbol, 0);
- if ((w = m->b.width - tw - x) > m->b.height) {
+ if ((w = m->b.width - (tw + x + traywidth)) > m->b.height) {
if (c) {
drwl_setscheme(m->drw, colors[m == selmon ? SchemeSel : SchemeNorm]);
drwl_text(m->drw, x, 0, w, m->b.height, m->lrpad / 2, client_get_title(c), 0);
@@ -1560,6 +1602,15 @@ drawbar(Monitor *m)
}
}
+ if (traywidth > 0) {
+ pixman_image_composite32(PIXMAN_OP_SRC,
+ m->tray->image, NULL, m->drw->image,
+ 0, 0,
+ 0, 0,
+ m->b.width - traywidth, 0,
+ traywidth, m->b.height);
+ }
+
wlr_scene_buffer_set_dest_size(m->scene_buffer,
m->b.real_width, m->b.real_height);
wlr_scene_node_set_position(&m->scene_buffer->node, m->m.x,
@@ -1568,6 +1619,26 @@ drawbar(Monitor *m)
wlr_buffer_unlock(&buf->base);
}
+void
+traynotify(void *data)
+{
+ Monitor *m = data;
+
+ drawbar(m);
+}
+
+void
+trayactivate(const Arg *arg)
+{
+ tray_leftclicked(selmon->tray, arg->ui);
+}
+
+void
+traymenu(const Arg *arg)
+{
+ tray_rightclicked(selmon->tray, arg->ui, dmenucmd);
+}
+
void
drawbars(void)
{
@@ -2818,6 +2889,15 @@ setup(void)
status_event_source = wl_event_loop_add_fd(wl_display_get_event_loop(dpy),
STDIN_FILENO, WL_EVENT_READABLE, statusin, NULL);
+ bus_conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
+ if (!bus_conn)
+ die("Failed to connect to bus");
+ bus_source = startbus(bus_conn, event_loop);
+ if (!bus_source)
+ die("Failed to start listening to bus events");
+ if (showbar && showsystray)
+ watcher_start(&watcher, bus_conn, event_loop);
+
/* Make sure XWayland clients don't connect to the parent X server,
* e.g when running in the x11 backend or the wayland backend and the
* compositor has Xwayland support */
@@ -3160,6 +3240,7 @@ updatebar(Monitor *m)
size_t i;
int rw, rh;
char fontattrs[12];
+ Tray *tray;
wlr_output_transformed_resolution(m->wlr_output, &rw, &rh);
m->b.width = rw;
@@ -3185,6 +3266,18 @@ updatebar(Monitor *m)
m->lrpad = m->drw->font->height;
m->b.height = m->drw->font->height + 2;
m->b.real_height = (int)((float)m->b.height / m->wlr_output->scale);
+
+ if (showsystray) {
+ if (m->tray)
+ destroytray(m->tray);
+ tray = createtray(m,
+ m->b.height, systrayspacing, colors[SchemeNorm], fonts, fontattrs,
+ &traynotify, &watcher);
+ if (!tray)
+ die("Couldn't create tray for monitor");
+ m->tray = tray;
+ wl_list_insert(&watcher.trays, &tray->link);
+ }
}
void
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/item.c b/systray/item.c
new file mode 100644
index 0000000..4359a28
--- /dev/null
+++ b/systray/item.c
@@ -0,0 +1,403 @@
+#include "item.h"
+
+#include "helpers.h"
+#include "icon.h"
+#include "watcher.h"
+
+#include <dbus/dbus.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// IWYU pragma: no_include "dbus/dbus-protocol.h"
+// IWYU pragma: no_include "dbus/dbus-shared.h"
+
+#define RULEBSIZE 256
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
+static const char *match_string =
+ "type='signal',"
+ "sender='%s',"
+ "interface='" SNI_NAME
+ "',"
+ "member='NewIcon'";
+
+static Watcher *
+item_get_watcher(const Item *item)
+{
+ if (!item)
+ return NULL;
+
+ return item->watcher;
+}
+
+static DBusConnection *
+item_get_connection(const Item *item)
+{
+ if (!item || !item->watcher)
+ return NULL;
+
+ return item->watcher->conn;
+}
+
+static const uint8_t *
+extract_image(DBusMessageIter *iter, dbus_int32_t *width, dbus_int32_t *height,
+ int *size)
+{
+ DBusMessageIter vals, bytes;
+ const uint8_t *buf;
+
+ dbus_message_iter_recurse(iter, &vals);
+ if (dbus_message_iter_get_arg_type(&vals) != DBUS_TYPE_INT32)
+ goto fail;
+ dbus_message_iter_get_basic(&vals, width);
+
+ dbus_message_iter_next(&vals);
+ if (dbus_message_iter_get_arg_type(&vals) != DBUS_TYPE_INT32)
+ goto fail;
+ dbus_message_iter_get_basic(&vals, height);
+
+ dbus_message_iter_next(&vals);
+ if (dbus_message_iter_get_arg_type(&vals) != DBUS_TYPE_ARRAY)
+ goto fail;
+ dbus_message_iter_recurse(&vals, &bytes);
+ if (dbus_message_iter_get_arg_type(&bytes) != DBUS_TYPE_BYTE)
+ goto fail;
+ dbus_message_iter_get_fixed_array(&bytes, &buf, size);
+ if (size == 0)
+ goto fail;
+
+ return buf;
+
+fail:
+ return NULL;
+}
+
+static int
+select_image(DBusMessageIter *iter, int target_width)
+{
+ DBusMessageIter vals;
+ dbus_int32_t cur_width;
+ int i = 0;
+
+ do {
+ dbus_message_iter_recurse(iter, &vals);
+ if (dbus_message_iter_get_arg_type(&vals) != DBUS_TYPE_INT32)
+ return -1;
+ dbus_message_iter_get_basic(&vals, &cur_width);
+ if (cur_width >= target_width)
+ return i;
+
+ i++;
+ } while (dbus_message_iter_next(iter));
+
+ /* return last index if desired not found */
+ return --i;
+}
+
+static void
+menupath_ready_handler(DBusPendingCall *pending, void *data)
+{
+ Item *item = data;
+
+ DBusError err = DBUS_ERROR_INIT;
+ DBusMessage *reply = NULL;
+ DBusMessageIter iter, opath;
+ char *path_dup = NULL;
+ const char *path;
+
+ reply = dbus_pending_call_steal_reply(pending);
+ if (!reply)
+ goto fail;
+
+ if (dbus_set_error_from_message(&err, reply)) {
+ fprintf(stderr, "DBus Error: %s - %s: Couldn't get menupath\n",
+ err.name, err.message);
+ goto fail;
+ }
+
+ dbus_message_iter_init(reply, &iter);
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ goto fail;
+ dbus_message_iter_recurse(&iter, &opath);
+ if (dbus_message_iter_get_arg_type(&opath) != DBUS_TYPE_OBJECT_PATH)
+ goto fail;
+ dbus_message_iter_get_basic(&opath, &path);
+
+ path_dup = strdup(path);
+ if (!path_dup)
+ goto fail;
+
+ item->menu_busobj = path_dup;
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(pending);
+ return;
+
+fail:
+ free(path_dup);
+ dbus_error_free(&err);
+ if (reply)
+ dbus_message_unref(reply);
+ if (pending)
+ dbus_pending_call_unref(pending);
+}
+
+/*
+ * Gets the Id dbus property, which is the name of the application,
+ * most of the time...
+ * The initial letter will be used as a fallback icon
+ */
+static void
+id_ready_handler(DBusPendingCall *pending, void *data)
+{
+ Item *item = data;
+
+ DBusError err = DBUS_ERROR_INIT;
+ DBusMessage *reply = NULL;
+ DBusMessageIter iter, string;
+ Watcher *watcher;
+ char *id_dup = NULL;
+ const char *id;
+
+ watcher = item_get_watcher(item);
+
+ reply = dbus_pending_call_steal_reply(pending);
+ if (!reply)
+ goto fail;
+
+ if (dbus_set_error_from_message(&err, reply)) {
+ fprintf(stderr, "DBus Error: %s - %s: Couldn't get appid\n",
+ err.name, err.message);
+ goto fail;
+ }
+
+ dbus_message_iter_init(reply, &iter);
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ goto fail;
+ dbus_message_iter_recurse(&iter, &string);
+ if (dbus_message_iter_get_arg_type(&string) != DBUS_TYPE_STRING)
+ goto fail;
+ dbus_message_iter_get_basic(&string, &id);
+
+ id_dup = strdup(id);
+ if (!id_dup)
+ goto fail;
+ item->appid = id_dup;
+
+ /* Don't trigger update if this item already has a real icon */
+ if (!item->icon)
+ watcher_update_trays(watcher);
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(pending);
+ return;
+
+fail:
+ dbus_error_free(&err);
+ if (id_dup)
+ free(id_dup);
+ if (reply)
+ dbus_message_unref(reply);
+ if (pending)
+ dbus_pending_call_unref(pending);
+}
+
+static void
+pixmap_ready_handler(DBusPendingCall *pending, void *data)
+{
+ Item *item = data;
+
+ DBusMessage *reply = NULL;
+ DBusMessageIter iter, array, select, strct;
+ Icon *icon = NULL;
+ Watcher *watcher;
+ dbus_int32_t width, height;
+ int selected_index, size;
+ const uint8_t *buf;
+
+ watcher = item_get_watcher(item);
+
+ reply = dbus_pending_call_steal_reply(pending);
+ if (!reply || dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto fail;
+ dbus_message_iter_init(reply, &iter);
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ goto fail;
+ dbus_message_iter_recurse(&iter, &array);
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ goto fail;
+ dbus_message_iter_recurse(&array, &select);
+ if (dbus_message_iter_get_arg_type(&select) != DBUS_TYPE_STRUCT)
+ goto fail;
+ selected_index = select_image(&select, 22); // Get the 22*22 image
+ if (selected_index < 0)
+ goto fail;
+
+ dbus_message_iter_recurse(&array, &strct);
+ if (dbus_message_iter_get_arg_type(&strct) != DBUS_TYPE_STRUCT)
+ goto fail;
+ for (int i = 0; i < selected_index; i++)
+ dbus_message_iter_next(&strct);
+ buf = extract_image(&strct, &width, &height, &size);
+ if (!buf)
+ goto fail;
+
+ if (!item->icon) {
+ /* First icon */
+ icon = createicon(buf, width, height, size);
+ if (!icon)
+ goto fail;
+ item->icon = icon;
+ watcher_update_trays(watcher);
+
+ } else if (memcmp(item->icon->buf_orig, buf,
+ MIN(item->icon->size_orig, (size_t)size)) != 0) {
+ /* New icon */
+ destroyicon(item->icon);
+ item->icon = NULL;
+ icon = createicon(buf, width, height, size);
+ if (!icon)
+ goto fail;
+ item->icon = icon;
+ watcher_update_trays(watcher);
+
+ } else {
+ /* Icon didn't change */
+ }
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(pending);
+ return;
+
+fail:
+ if (icon)
+ destroyicon(icon);
+ if (reply)
+ dbus_message_unref(reply);
+ if (pending)
+ dbus_pending_call_unref(pending);
+}
+
+static DBusHandlerResult
+handle_newicon(Item *item, DBusConnection *conn, DBusMessage *msg)
+{
+ const char *sender = dbus_message_get_sender(msg);
+
+ if (sender && strcmp(sender, item->busname) == 0) {
+ request_property(conn, item->busname, item->busobj,
+ "IconPixmap", SNI_IFACE, pixmap_ready_handler,
+ item);
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+
+ } else {
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+}
+
+static DBusHandlerResult
+filter_bus(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ Item *item = data;
+
+ if (dbus_message_is_signal(msg, SNI_IFACE, "NewIcon"))
+ return handle_newicon(item, conn, msg);
+ else
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+Item *
+createitem(const char *busname, const char *busobj, Watcher *watcher)
+{
+ DBusConnection *conn;
+ Item *item;
+ char *busname_dup = NULL;
+ char *busobj_dup = NULL;
+ char match_rule[RULEBSIZE];
+
+ item = calloc(1, sizeof(Item));
+ busname_dup = strdup(busname);
+ busobj_dup = strdup(busobj);
+ if (!item || !busname_dup || !busobj_dup)
+ goto fail;
+
+ conn = watcher->conn;
+ item->busname = busname_dup;
+ item->busobj = busobj_dup;
+ item->watcher = watcher;
+
+ request_property(conn, busname, busobj, "IconPixmap", SNI_IFACE,
+ pixmap_ready_handler, item);
+
+ request_property(conn, busname, busobj, "Id", SNI_IFACE,
+ id_ready_handler, item);
+
+ request_property(conn, busname, busobj, "Menu", SNI_IFACE,
+ menupath_ready_handler, item);
+
+ if (snprintf(match_rule, sizeof(match_rule), match_string, busname) >=
+ RULEBSIZE) {
+ goto fail;
+ }
+
+ if (!dbus_connection_add_filter(conn, filter_bus, item, NULL))
+ goto fail;
+ dbus_bus_add_match(conn, match_rule, NULL);
+
+ return item;
+
+fail:
+ free(busname_dup);
+ free(busobj_dup);
+ return NULL;
+}
+
+void
+destroyitem(Item *item)
+{
+ DBusConnection *conn;
+ char match_rule[RULEBSIZE];
+
+ conn = item_get_connection(item);
+
+ if (snprintf(match_rule, sizeof(match_rule), match_string,
+ item->busname) < RULEBSIZE) {
+ dbus_bus_remove_match(conn, match_rule, NULL);
+ dbus_connection_remove_filter(conn, filter_bus, item);
+ }
+ if (item->icon)
+ destroyicon(item->icon);
+ free(item->menu_busobj);
+ free(item->busname);
+ free(item->busobj);
+ free(item->appid);
+ free(item);
+}
+
+void
+item_activate(Item *item)
+{
+ DBusConnection *conn;
+ DBusMessage *msg = NULL;
+ dbus_int32_t x = 0, y = 0;
+
+ conn = item_get_connection(item);
+
+ if (!(msg = dbus_message_new_method_call(item->busname, item->busobj,
+ SNI_IFACE, "Activate")) ||
+ !dbus_message_append_args(msg, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32,
+ &y, DBUS_TYPE_INVALID) ||
+ !dbus_connection_send_with_reply(conn, msg, NULL, -1)) {
+ goto fail;
+ }
+
+ dbus_message_unref(msg);
+ return;
+
+fail:
+ if (msg)
+ dbus_message_unref(msg);
+}
diff --git a/systray/item.h b/systray/item.h
new file mode 100644
index 0000000..dc22e25
--- /dev/null
+++ b/systray/item.h
@@ -0,0 +1,46 @@
+#ifndef ITEM_H
+#define ITEM_H
+
+#include "icon.h"
+#include "watcher.h"
+
+#include <wayland-util.h>
+
+/*
+ * The FDO spec says "org.freedesktop.StatusNotifierItem"[1],
+ * but both the client libraries[2,3] actually use "org.kde.StatusNotifierItem"
+ *
+ * [1] https://www.freedesktop.org/wiki/Specifications/StatusNotifierItem/
+ * [2] https://github.com/AyatanaIndicators/libayatana-appindicator-glib
+ * [3] https://invent.kde.org/frameworks/kstatusnotifieritem
+ *
+ */
+#define SNI_NAME "org.kde.StatusNotifierItem"
+#define SNI_OPATH "/StatusNotifierItem"
+#define SNI_IFACE "org.kde.StatusNotifierItem"
+
+typedef struct Item {
+ struct wl_list icons;
+ char *busname;
+ char *busobj;
+ char *menu_busobj;
+ char *appid;
+ Icon *icon;
+ FallbackIcon *fallback_icon;
+
+ Watcher *watcher;
+
+ int fgcolor;
+
+ int ready;
+
+ struct wl_list link;
+} Item;
+
+Item *createitem (const char *busname, const char *busobj, Watcher *watcher);
+void destroyitem (Item *item);
+
+void item_activate (Item *item);
+void item_show_menu (Item *item);
+
+#endif /* ITEM_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..8dd84b9
--- /dev/null
+++ b/systray/watcher.c
@@ -0,0 +1,551 @@
+#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 };
+
+void
+watcher_start(Watcher *watcher, DBusConnection *conn,
+ struct wl_event_loop *loop)
+{
+ DBusError err = DBUS_ERROR_INIT;
+ int r, flags;
+
+ wl_list_init(&watcher->items);
+ wl_list_init(&watcher->trays);
+ watcher->conn = conn;
+ watcher->loop = loop;
+
+ flags = DBUS_NAME_FLAG_REPLACE_EXISTING | DBUS_NAME_FLAG_DO_NOT_QUEUE;
+ r = dbus_bus_request_name(conn, SNW_NAME,
+ flags, 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;
+ }
+
+ watcher->running = 1;
+ return;
+
+fail:
+ fprintf(stderr, "Couldn't start watcher, systray not available\n");
+ dbus_error_free(&err);
+ return;
+}
+
+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);
+ watcher->running = 0;
+}
+
+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..127eb64
--- /dev/null
+++ b/systray/watcher.h
@@ -0,0 +1,35 @@
+#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;
+ int running;
+} Watcher;
+
+void 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 */
--
2.49.0
Reference in New Issue View Git Blame Copy Permalink