mirror of
https://github.com/swaywm/sway.git
synced 2024-11-16 05:03:17 +00:00
399 lines
10 KiB
C
399 lines
10 KiB
C
#define _XOPEN_SOURCE 700
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/wait.h>
|
|
#include <dbus/dbus.h>
|
|
#include "swaybar/bar.h"
|
|
#include "swaybar/tray/tray.h"
|
|
#include "swaybar/tray/dbus.h"
|
|
#include "swaybar/tray/sni.h"
|
|
#include "swaybar/tray/sni_watcher.h"
|
|
#include "swaybar/bar.h"
|
|
#include "swaybar/config.h"
|
|
#include "list.h"
|
|
#include "log.h"
|
|
|
|
struct tray *tray;
|
|
|
|
static void register_host(char *name) {
|
|
DBusMessage *message;
|
|
|
|
message = dbus_message_new_method_call(
|
|
"org.freedesktop.StatusNotifierWatcher",
|
|
"/StatusNotifierWatcher",
|
|
"org.freedesktop.StatusNotifierWatcher",
|
|
"RegisterStatusNotifierHost");
|
|
if (!message) {
|
|
sway_log(L_ERROR, "Cannot allocate dbus method call");
|
|
return;
|
|
}
|
|
|
|
dbus_message_append_args(message,
|
|
DBUS_TYPE_STRING, &name,
|
|
DBUS_TYPE_INVALID);
|
|
|
|
dbus_connection_send(conn, message, NULL);
|
|
|
|
dbus_message_unref(message);
|
|
}
|
|
|
|
static void get_items_reply(DBusPendingCall *pending, void *_data) {
|
|
DBusMessage *reply = dbus_pending_call_steal_reply(pending);
|
|
|
|
if (!reply) {
|
|
sway_log(L_ERROR, "Got no items reply from sni watcher");
|
|
goto bail;
|
|
}
|
|
|
|
int message_type = dbus_message_get_type(reply);
|
|
|
|
if (message_type == DBUS_MESSAGE_TYPE_ERROR) {
|
|
char *msg;
|
|
|
|
dbus_message_get_args(reply, NULL,
|
|
DBUS_TYPE_STRING, &msg,
|
|
DBUS_TYPE_INVALID);
|
|
|
|
sway_log(L_ERROR, "Message is error: %s", msg);
|
|
goto bail;
|
|
}
|
|
|
|
DBusMessageIter iter;
|
|
DBusMessageIter variant;
|
|
DBusMessageIter array;
|
|
|
|
dbus_message_iter_init(reply, &iter);
|
|
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
|
|
sway_log(L_ERROR, "Replyed with wrong type, not v(as)");
|
|
goto bail;
|
|
}
|
|
dbus_message_iter_recurse(&iter, &variant);
|
|
if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY ||
|
|
dbus_message_iter_get_element_type(&variant) != DBUS_TYPE_STRING) {
|
|
sway_log(L_ERROR, "Replyed with wrong type, not v(as)");
|
|
goto bail;
|
|
}
|
|
|
|
// Clear list
|
|
list_foreach(tray->items, (void (*)(void *))sni_free);
|
|
list_free(tray->items);
|
|
tray->items = create_list();
|
|
|
|
// O(n) function, could be faster dynamically reading values
|
|
int len = dbus_message_iter_get_element_count(&variant);
|
|
|
|
dbus_message_iter_recurse(&variant, &array);
|
|
for (int i = 0; i < len; i++) {
|
|
const char *name;
|
|
dbus_message_iter_get_basic(&array, &name);
|
|
|
|
struct StatusNotifierItem *item = sni_create(name);
|
|
|
|
if (item) {
|
|
sway_log(L_DEBUG, "Item registered with host: %s", name);
|
|
list_add(tray->items, item);
|
|
dirty = true;
|
|
}
|
|
}
|
|
|
|
bail:
|
|
dbus_message_unref(reply);
|
|
dbus_pending_call_unref(pending);
|
|
return;
|
|
}
|
|
static void get_items() {
|
|
DBusPendingCall *pending;
|
|
DBusMessage *message = dbus_message_new_method_call(
|
|
"org.freedesktop.StatusNotifierWatcher",
|
|
"/StatusNotifierWatcher",
|
|
"org.freedesktop.DBus.Properties",
|
|
"Get");
|
|
|
|
const char *iface = "org.freedesktop.StatusNotifierWatcher";
|
|
const char *prop = "RegisteredStatusNotifierItems";
|
|
dbus_message_append_args(message,
|
|
DBUS_TYPE_STRING, &iface,
|
|
DBUS_TYPE_STRING, &prop,
|
|
DBUS_TYPE_INVALID);
|
|
|
|
bool status =
|
|
dbus_connection_send_with_reply(conn, message, &pending, -1);
|
|
dbus_message_unref(message);
|
|
|
|
if (!(pending || status)) {
|
|
sway_log(L_ERROR, "Could not get items");
|
|
return;
|
|
}
|
|
|
|
dbus_pending_call_set_notify(pending, get_items_reply, NULL, NULL);
|
|
}
|
|
|
|
static DBusHandlerResult signal_handler(DBusConnection *connection,
|
|
DBusMessage *message, void *_data) {
|
|
if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierWatcher",
|
|
"StatusNotifierItemRegistered")) {
|
|
const char *name;
|
|
if (!dbus_message_get_args(message, NULL,
|
|
DBUS_TYPE_STRING, &name,
|
|
DBUS_TYPE_INVALID)) {
|
|
sway_log(L_ERROR, "Error getting StatusNotifierItemRegistered args");
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
if (list_seq_find(tray->items, sni_str_cmp, name) == -1) {
|
|
struct StatusNotifierItem *item = sni_create(name);
|
|
|
|
if (item) {
|
|
list_add(tray->items, item);
|
|
dirty = true;
|
|
}
|
|
}
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
} else if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierWatcher",
|
|
"StatusNotifierItemUnregistered")) {
|
|
const char *name;
|
|
if (!dbus_message_get_args(message, NULL,
|
|
DBUS_TYPE_STRING, &name,
|
|
DBUS_TYPE_INVALID)) {
|
|
sway_log(L_ERROR, "Error getting StatusNotifierItemUnregistered args");
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
int index;
|
|
if ((index = list_seq_find(tray->items, sni_str_cmp, name)) != -1) {
|
|
sni_free(tray->items->items[index]);
|
|
list_del(tray->items, index);
|
|
dirty = true;
|
|
} else {
|
|
// If it's not in our list, then our list is incorrect.
|
|
// Fetch all items again
|
|
sway_log(L_INFO, "Host item list incorrect, refreshing");
|
|
get_items();
|
|
}
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
} else if (dbus_message_is_signal(message, "org.freedesktop.StatusNotifierItem",
|
|
"NewIcon") || dbus_message_is_signal(message,
|
|
"org.kde.StatusNotifierItem", "NewIcon")) {
|
|
const char *name;
|
|
int index;
|
|
struct StatusNotifierItem *item;
|
|
|
|
name = dbus_message_get_sender(message);
|
|
if ((index = list_seq_find(tray->items, sni_uniq_cmp, name)) != -1) {
|
|
item = tray->items->items[index];
|
|
sway_log(L_INFO, "NewIcon signal from item %s", item->name);
|
|
get_icon(item);
|
|
}
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
}
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
}
|
|
|
|
static int init_host() {
|
|
tray = (struct tray *)malloc(sizeof(tray));
|
|
|
|
tray->items = create_list();
|
|
|
|
DBusError error;
|
|
dbus_error_init(&error);
|
|
char *name = NULL;
|
|
if (!conn) {
|
|
sway_log(L_ERROR, "Connection is null, cannot init SNI host");
|
|
goto err;
|
|
}
|
|
name = calloc(sizeof(char), 256);
|
|
|
|
if (!name) {
|
|
sway_log(L_ERROR, "Cannot allocate name");
|
|
goto err;
|
|
}
|
|
|
|
pid_t pid = getpid();
|
|
if (snprintf(name, 256, "org.freedesktop.StatusNotifierHost-%d", pid)
|
|
>= 256) {
|
|
sway_log(L_ERROR, "Cannot get host name because string is too short."
|
|
"This should not happen");
|
|
goto err;
|
|
}
|
|
|
|
// We want to be the sole owner of this name
|
|
if (dbus_bus_request_name(conn, name, DBUS_NAME_FLAG_DO_NOT_QUEUE,
|
|
&error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
|
|
sway_log(L_ERROR, "Cannot get host name and start the tray");
|
|
goto err;
|
|
}
|
|
if (dbus_error_is_set(&error)) {
|
|
sway_log(L_ERROR, "Dbus err getting host name: %s\n", error.message);
|
|
goto err;
|
|
}
|
|
sway_log(L_DEBUG, "Got host name");
|
|
|
|
register_host(name);
|
|
|
|
get_items();
|
|
|
|
// Perhaps use addmatch helper functions like wlc does?
|
|
dbus_bus_add_match(conn,
|
|
"type='signal',\
|
|
sender='org.freedesktop.StatusNotifierWatcher',\
|
|
member='StatusNotifierItemRegistered'",
|
|
&error);
|
|
if (dbus_error_is_set(&error)) {
|
|
sway_log(L_ERROR, "dbus_err: %s", error.message);
|
|
goto err;
|
|
}
|
|
dbus_bus_add_match(conn,
|
|
"type='signal',\
|
|
sender='org.freedesktop.StatusNotifierWatcher',\
|
|
member='StatusNotifierItemUnregistered'",
|
|
&error);
|
|
if (dbus_error_is_set(&error)) {
|
|
sway_log(L_ERROR, "dbus_err: %s", error.message);
|
|
return -1;
|
|
}
|
|
|
|
// SNI matches
|
|
dbus_bus_add_match(conn,
|
|
"type='signal',\
|
|
interface='org.freedesktop.StatusNotifierItem',\
|
|
member='NewIcon'",
|
|
&error);
|
|
if (dbus_error_is_set(&error)) {
|
|
sway_log(L_ERROR, "dbus_err %s", error.message);
|
|
goto err;
|
|
}
|
|
dbus_bus_add_match(conn,
|
|
"type='signal',\
|
|
interface='org.kde.StatusNotifierItem',\
|
|
member='NewIcon'",
|
|
&error);
|
|
if (dbus_error_is_set(&error)) {
|
|
sway_log(L_ERROR, "dbus_err %s", error.message);
|
|
goto err;
|
|
}
|
|
|
|
dbus_connection_add_filter(conn, signal_handler, NULL, NULL);
|
|
|
|
free(name);
|
|
return 0;
|
|
|
|
err:
|
|
// TODO better handle errors
|
|
free(name);
|
|
return -1;
|
|
}
|
|
|
|
void tray_mouse_event(struct output *output, int x, int y,
|
|
uint32_t button, uint32_t state) {
|
|
|
|
struct window *window = output->window;
|
|
uint32_t tray_padding = swaybar.config->tray_padding;
|
|
int tray_width = window->width * window->scale;
|
|
|
|
for (int i = 0; i < output->items->length; ++i) {
|
|
struct sni_icon_ref *item =
|
|
output->items->items[i];
|
|
int icon_width = cairo_image_surface_get_width(item->icon);
|
|
|
|
tray_width -= tray_padding;
|
|
if (x <= tray_width && x >= tray_width - icon_width) {
|
|
if (button == swaybar.config->activate_button) {
|
|
sni_activate(item->ref, x, y);
|
|
} else if (button == swaybar.config->context_button) {
|
|
sni_context_menu(item->ref, x, y);
|
|
} else if (button == swaybar.config->secondary_button) {
|
|
sni_secondary(item->ref, x, y);
|
|
}
|
|
break;
|
|
}
|
|
tray_width -= icon_width;
|
|
}
|
|
}
|
|
|
|
uint32_t tray_render(struct output *output, struct config *config) {
|
|
struct window *window = output->window;
|
|
cairo_t *cairo = window->cairo;
|
|
|
|
// Tray icons
|
|
uint32_t tray_padding = config->tray_padding;
|
|
uint32_t tray_width = window->width * window->scale;
|
|
const int item_size = (window->height * window->scale) - (2 * tray_padding);
|
|
|
|
if (item_size < 0) {
|
|
// Can't render items if the padding is too large
|
|
return tray_width;
|
|
}
|
|
|
|
if (config->tray_output && strcmp(config->tray_output, output->name) != 0) {
|
|
return tray_width;
|
|
}
|
|
|
|
for (int i = 0; i < tray->items->length; ++i) {
|
|
struct StatusNotifierItem *item =
|
|
tray->items->items[i];
|
|
if (!item->image) {
|
|
continue;
|
|
}
|
|
|
|
struct sni_icon_ref *render_item = NULL;
|
|
int j;
|
|
for (j = i; j < output->items->length; ++j) {
|
|
struct sni_icon_ref *ref =
|
|
output->items->items[j];
|
|
if (ref->ref == item) {
|
|
render_item = ref;
|
|
break;
|
|
} else {
|
|
sni_icon_ref_free(ref);
|
|
list_del(output->items, j);
|
|
}
|
|
}
|
|
|
|
if (!render_item) {
|
|
render_item = sni_icon_ref_create(item, item_size);
|
|
list_add(output->items, render_item);
|
|
} else if (item->dirty) {
|
|
// item needs re-render
|
|
sni_icon_ref_free(render_item);
|
|
output->items->items[j] = render_item =
|
|
sni_icon_ref_create(item, item_size);
|
|
}
|
|
|
|
tray_width -= tray_padding;
|
|
tray_width -= item_size;
|
|
|
|
cairo_operator_t op = cairo_get_operator(cairo);
|
|
cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
|
|
cairo_set_source_surface(cairo, render_item->icon, tray_width, tray_padding);
|
|
cairo_rectangle(cairo, tray_width, tray_padding, item_size, item_size);
|
|
cairo_fill(cairo);
|
|
cairo_set_operator(cairo, op);
|
|
|
|
item->dirty = false;
|
|
}
|
|
|
|
|
|
if (tray_width != window->width * window->scale) {
|
|
tray_width -= tray_padding;
|
|
}
|
|
|
|
return tray_width;
|
|
}
|
|
|
|
void init_tray(struct bar *bar) {
|
|
if (!bar->config->tray_output || strcmp(bar->config->tray_output, "none") != 0) {
|
|
/* Connect to the D-Bus */
|
|
dbus_init();
|
|
|
|
/* Start the SNI watcher */
|
|
init_sni_watcher();
|
|
|
|
/* Start the SNI host */
|
|
init_host();
|
|
}
|
|
}
|