TrayIcon.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "TrayIcon.hpp"
 
#include <arpa/inet.h>
#include <chrono>
#include <cstring>
#include <random>
#include <thread>
#include <unistd.h>
#include <vector>
#include <glibmm/main.h>
#include <string>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <cstdio>
#include <glib.h>
#include <glib/gi18n.h>
#include <inttypes.h>
 
#define TI_LOG(fmt, ...) \
    std::fprintf(stderr, "[TrayIcon] " fmt "\n", ##__VA_ARGS__)
 
static gboolean invoke_std_function(gpointer data) {
    auto* fn = static_cast<std::function<void()>*>(data);
    (*fn)();
    delete fn;
    return G_SOURCE_REMOVE;
}
 
 
 
static const sd_bus_vtable sni_vtable[] = {
    SD_BUS_VTABLE_START(0),
 
    SD_BUS_METHOD("Activate",          "ii", "", TrayIcon::sni_method_activate,           SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("ContextMenu",       "ii", "", TrayIcon::sni_method_context_menu,       SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("SecondaryActivate", "ii", "", TrayIcon::sni_method_secondary_activate, SD_BUS_VTABLE_UNPRIVILEGED),
 
    SD_BUS_PROPERTY("Category",   "s",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_CONST),
    SD_BUS_PROPERTY("Id",         "s",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_CONST),
    SD_BUS_PROPERTY("Title",      "s",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
    SD_BUS_PROPERTY("Status",     "s",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
    SD_BUS_PROPERTY("IconName",   "s",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
    SD_BUS_PROPERTY("IconPixmap", "a(iiay)",      TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
    SD_BUS_PROPERTY("ToolTip",    "(sa(iiay)ss)", TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
    SD_BUS_PROPERTY("Menu",       "o",            TrayIcon::sni_prop_get, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 
    SD_BUS_SIGNAL("NewIcon",    "", 0),
    SD_BUS_SIGNAL("NewTitle",   "", 0),
    SD_BUS_SIGNAL("NewStatus",  "", 0),
    SD_BUS_SIGNAL("NewToolTip", "", 0),
 
    SD_BUS_VTABLE_END
};
 
 
static const sd_bus_vtable dbusmenu_vtable[] = {
    SD_BUS_VTABLE_START(0),
 
    SD_BUS_METHOD("GetLayout",          "iias",    "u(ia{sv}av)", TrayIcon::dbusmenu_method_get_layout,           SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("GetChildren",        "i",       "ai",          TrayIcon::dbusmenu_method_get_children,         SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("GetGroupProperties", "aias",    "a(ia{sv})",   TrayIcon::dbusmenu_method_get_group_properties, SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("GetProperty",        "is",      "v",           TrayIcon::dbusmenu_method_get_property,         SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("GetStatus",          "",        "s",           TrayIcon::dbusmenu_method_get_status,           SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("Event",              "isvu",    "",            TrayIcon::dbusmenu_method_event,                SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("AboutToShow",        "i",       "b",           TrayIcon::dbusmenu_method_about_to_show,        SD_BUS_VTABLE_UNPRIVILEGED),
    // ↓↓ SPOSTATI QUI da sni_vtable ↓↓
    SD_BUS_METHOD("EventGroup",         "a(isvu)", "ai",          TrayIcon::dbusmenu_method_event_group,          SD_BUS_VTABLE_UNPRIVILEGED),
    SD_BUS_METHOD("AboutToShowGroup",   "ai",      "aiai",        TrayIcon::dbusmenu_method_about_to_show_group,  SD_BUS_VTABLE_UNPRIVILEGED),
 
    SD_BUS_PROPERTY("Version", "u", TrayIcon::dbusmenu_prop_get, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 
    SD_BUS_SIGNAL("LayoutUpdated",          "ui",              0),
    SD_BUS_SIGNAL("ItemsPropertiesUpdated", "a(ia{sv})a(ias)", 0),
 
    SD_BUS_VTABLE_END
};
 
static inline const char* label_for_menu_id(int id) {
    switch (id) {
        case 1: return _("Mostra/Maximizza finestra");
        case 2: return _("Impostazioni");
        case 3: return _("Esci");
        default: return "";
    }
}
 
static inline bool enabled_for_menu_id(int) {
    return true;
}
 
 
std::string TrayIcon::make_service_name() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dis(1000, 9999);
    return "org.kde.StatusNotifierItem-" + std::to_string(getpid()) + "-" + std::to_string(dis(gen));
}
 
TrayIcon::TrayIcon() {
    service_name_ = make_service_name();
    id_        = "BastionGuard";
    title_     = "BastionGuard";
    status_    = "Active";
    icon_name_ = "security-high";
    tooltip_   = "BastionGuard";
}
 
TrayIcon::~TrayIcon() {
    stop();
    if (ui_ctx_) {
        g_main_context_unref(ui_ctx_);
        ui_ctx_ = nullptr;
    }
}
 
bool TrayIcon::start() {
    if (running_.exchange(true)) return true;
 
    if (!acquire_bus())    { running_ = false; return false; }
    if (!request_name())   { release_bus(); running_ = false; return false; }
    if (!export_objects()) { release_bus(); running_ = false; return false; }
 
    bus_thread_ = std::thread([this]() {
        bool ok = register_to_watcher();
        std::fprintf(stderr, "[TrayIcon] register_to_watcher: %s (service: %s)\n",
                     ok ? "OK" : "FAILED", service_name_.c_str());
 
        std::this_thread::sleep_for(std::chrono::milliseconds(150));
        emit_dbusmenu_layout_updated();
 
        bus_loop();
    });
 
    return true;
}
 
int TrayIcon::dbusmenu_method_about_to_show_group(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    TI_LOG("AboutToShowGroup() called");
 
    int r = sd_bus_message_enter_container(m, 'a', "i");
    if (r < 0) return r;
 
    std::vector<int32_t> ids;
    for (;;) {
        int32_t id = 0;
        r = sd_bus_message_read(m, "i", &id);
        if (r < 0) return r;
        if (r == 0) break;
        ids.push_back(id);
    }
 
    r = sd_bus_message_exit_container(m);
    if (r < 0) return r;
 
    TI_LOG("AboutToShowGroup ids count=%zu", ids.size());
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    r = sd_bus_message_open_container(reply, 'a', "i");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_open_container(reply, 'a', "i");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}
 
int TrayIcon::dbusmenu_method_event_group(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    TI_LOG("EventGroup() called");
 
    int r = sd_bus_message_enter_container(m, 'a', "(isvu)");
    if (r < 0) return r;
 
    struct Ev { int32_t id; std::string ev; uint32_t ts; };
    std::vector<Ev> events;
 
    for (;;) {
        r = sd_bus_message_enter_container(m, 'r', "isvu");
        if (r < 0) return r;
        if (r == 0) break;
 
        int32_t id = 0;
        const char* ev_c = nullptr;
        uint32_t ts = 0;
 
        r = sd_bus_message_read(m, "is", &id, &ev_c);
        if (r < 0) return r;
 
        r = sd_bus_message_skip(m, "v");
        if (r < 0) return r;
 
        r = sd_bus_message_read(m, "u", &ts);
        if (r < 0) return r;
 
        r = sd_bus_message_exit_container(m);
        if (r < 0) return r;
 
        std::string ev = ev_c ? ev_c : "";
        TI_LOG("EventGroup item: id=%d ev='%s' ts=%" PRIu32, (int)id, ev.c_str(), ts);
        events.push_back({id, ev, ts});
    }
 
    r = sd_bus_message_exit_container(m);
    if (r < 0) return r;
 
    if (!self->ui_ctx_) {
        TI_LOG("WARNING: ui_ctx_ null (bind_ui_context not called?)");
    } else {
        for (const auto& e : events) {
            const int32_t id = e.id;
            g_main_context_invoke(self->ui_ctx_, invoke_std_function,
                new std::function<void()>([self, id]() {
                    TI_LOG("Dispatch on UI: id=%d", (int)id);
 
                    if (id == MENU_SHOW) {
                        TI_LOG("-> MENU_SHOW");
                        if (self->on_activate_cb_) self->on_activate_cb_();
                        else TI_LOG("on_activate_cb_ is null");
                    } else if (id == MENU_SETTINGS) {
                        TI_LOG("-> MENU_SETTINGS");
                        if (self->on_settings_cb_) self->on_settings_cb_();
                        else TI_LOG("on_settings_cb_ is null");
                    } else if (id == MENU_QUIT) {
                        TI_LOG("-> MENU_QUIT");
                        if (self->on_quit_cb_) self->on_quit_cb_();
                        else TI_LOG("on_quit_cb_ is null");
                    } else {
                        TI_LOG("Unknown menu id=%d", (int)id);
                    }
                })
            );
        }
    }
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    r = sd_bus_message_open_container(reply, 'a', "i");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}
 
void TrayIcon::stop() {
    if (!running_.exchange(false)) return;
 
    if (bus_thread_.joinable() &&
        std::this_thread::get_id() == bus_thread_.get_id()) {
        return;
    }
 
    if (bus_thread_.joinable())
        bus_thread_.join();
 
    unexport_objects();
    release_bus();
}
 
void TrayIcon::bind_ui_context() {
    if (ui_ctx_) return;
    ui_ctx_ = g_main_context_ref(g_main_context_default());
}
 
void TrayIcon::set_icon_file(const std::string& png_path, int target_px) {
    GError* err = nullptr;
    GdkPixbuf* pb = gdk_pixbuf_new_from_file(png_path.c_str(), &err);
    if (!pb) {
        std::fprintf(stderr, "[TrayIcon] cannot load icon '%s': %s\n",
                     png_path.c_str(), err ? err->message : "unknown error");
        if (err) g_error_free(err);
        have_pixmap_ = false;
        emit_sni_signal("NewIcon");
        return;
    }
 
    if (target_px > 0) {
        int w = gdk_pixbuf_get_width(pb);
        int h = gdk_pixbuf_get_height(pb);
        if (w != target_px || h != target_px) {
            GdkPixbuf* scaled = gdk_pixbuf_scale_simple(pb, target_px, target_px, GDK_INTERP_BILINEAR);
            g_object_unref(pb);
            pb = scaled;
        }
    }
 
    GdkPixbuf* rgba = gdk_pixbuf_add_alpha(pb, FALSE, 0, 0, 0);
    g_object_unref(pb);
 
    pix_w_ = gdk_pixbuf_get_width(rgba);
    pix_h_ = gdk_pixbuf_get_height(rgba);
 
    const int rowstride = gdk_pixbuf_get_rowstride(rgba);
    const int nchan     = gdk_pixbuf_get_n_channels(rgba);
    const guchar* pixels = gdk_pixbuf_get_pixels(rgba);
 
    pix_rgba_.resize((size_t)pix_w_ * (size_t)pix_h_ * 4u);
 
    for (int y = 0; y < pix_h_; ++y) {
        const guchar* src = pixels + y * rowstride;
        uint8_t*      dst = pix_rgba_.data() + (size_t)y * (size_t)pix_w_ * 4u;
 
        for (int x = 0; x < pix_w_; ++x) {
            uint8_t r = src[x * nchan + 0];
            uint8_t g = src[x * nchan + 1];
            uint8_t b = src[x * nchan + 2];
            uint8_t a = (nchan >= 4) ? src[x * nchan + 3] : 255u;
 
            uint32_t argb = ((uint32_t)a << 24) |
                            ((uint32_t)r << 16) |
                            ((uint32_t)g <<  8) |
                             (uint32_t)b;
            argb = htobe32(argb);
            std::memcpy(dst + x * 4, &argb, 4);
        }
    }
 
    g_object_unref(rgba);
 
    have_pixmap_ = true;
    icon_name_.clear();
 
    emit_sni_signal("NewIcon");
}
 
void TrayIcon::set_icon(const std::string& icon_name) {
    icon_name_ = icon_name.empty() ? "security-high" : icon_name;
    emit_sni_signal("NewIcon");
}
 
void TrayIcon::set_tooltip(const std::string& text) {
    tooltip_ = text;
    emit_sni_signal("NewToolTip");
}
 
void TrayIcon::set_title(const std::string& title) {
    title_ = title;
    emit_sni_signal("NewTitle");
}
 
bool TrayIcon::acquire_bus() {
    if (sd_bus_open_user(&bus_) < 0) {
        bus_ = nullptr;
        return false;
    }
    return true;
}
 
bool TrayIcon::request_name() {
    int r = sd_bus_request_name(bus_, service_name_.c_str(), 0);
    return r >= 0;
}
 
void TrayIcon::release_bus() {
    if (!bus_) return;
    sd_bus_unref(bus_);
    bus_ = nullptr;
}
 
bool TrayIcon::export_objects() {
    int r1 = sd_bus_add_object_vtable(
        bus_, &sni_slot_,
        "/StatusNotifierItem",
        "org.kde.StatusNotifierItem",
        sni_vtable,
        this
    );
    if (r1 < 0) return false;
 
    int r2 = sd_bus_add_object_vtable(
        bus_, &menu_slot_,
        "/Menu",
        "com.canonical.dbusmenu",
        dbusmenu_vtable,
        this
    );
    if (r2 < 0) return false;
 
    return true;
}
 
void TrayIcon::unexport_objects() {
    if (sni_slot_)  { sd_bus_slot_unref(sni_slot_);  sni_slot_  = nullptr; }
    if (menu_slot_) { sd_bus_slot_unref(menu_slot_); menu_slot_ = nullptr; }
}
 
bool TrayIcon::register_to_watcher() {
    sd_bus_message* m  = nullptr;
    sd_bus_error    er = SD_BUS_ERROR_NULL;
 
    int r = sd_bus_message_new_method_call(
        bus_, &m,
        "org.kde.StatusNotifierWatcher",
        "/StatusNotifierWatcher",
        "org.kde.StatusNotifierWatcher",
        "RegisterStatusNotifierItem"
    );
    if (r < 0) return false;
 
    r = sd_bus_message_append(m, "s", service_name_.c_str());
    if (r < 0) { sd_bus_message_unref(m); return false; }
 
    r = sd_bus_call(bus_, m, 0, &er, nullptr);
    if (r < 0)
        std::fprintf(stderr, "[TrayIcon] RegisterStatusNotifierItem error: %s\n",
                     er.message ? er.message : "(unknown)");
 
    sd_bus_error_free(&er);
    sd_bus_message_unref(m);
    return r >= 0;
}
 
void TrayIcon::bus_loop() {
    while (running_) {
        for (;;) {
            int r = sd_bus_process(bus_, nullptr);
            if (r < 0) {
                running_ = false;
                break;
            }
            if (r == 0) break;
        }
 
        if (!running_) break;
 
        (void)sd_bus_wait(bus_, 100000);
    }
}
 
void TrayIcon::emit_sni_signal(const char* signal_name) {
    if (!bus_) return;
    (void)sd_bus_emit_signal(
        bus_,
        "/StatusNotifierItem",
        "org.kde.StatusNotifierItem",
        signal_name,
        ""
    );
}
 
void TrayIcon::emit_dbusmenu_layout_updated() {
    if (!bus_) return;
    const uint32_t revision = 1u;
    const int32_t  parent   = MENU_ROOT;
    (void)sd_bus_emit_signal(
        bus_,
        "/Menu",
        "com.canonical.dbusmenu",
        "LayoutUpdated",
        "ui",
        revision,
        parent
    );
}
 
int TrayIcon::sni_method_activate(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    std::fprintf(stderr, "[TrayIcon] SNI Activate received\n");
 
    if (!self->ui_ctx_) {
        std::fprintf(stderr, "[TrayIcon] WARNING: ui_ctx_ null in Activate -> fallback default\n");
        self->ui_ctx_ = g_main_context_ref(g_main_context_default());
    }
 
    if (self->on_activate_cb_) {
        g_main_context_invoke(self->ui_ctx_, invoke_std_function,
            new std::function<void()>([self]() {
                std::fprintf(stderr, "[TrayIcon] SNI Activate dispatch on UI thread\n");
                self->on_activate_cb_();
            })
        );
    }
 
    return sd_bus_reply_method_return(m, "");
}
 
int TrayIcon::sni_method_context_menu(sd_bus_message* m, void*, sd_bus_error*) {
    return sd_bus_reply_method_return(m, "");
}
 
int TrayIcon::sni_method_secondary_activate(sd_bus_message* m, void*, sd_bus_error*) {
    return sd_bus_reply_method_return(m, "");
}
 
int TrayIcon::sni_prop_get(sd_bus*, const char*, const char*,
                           const char* property, sd_bus_message* reply,
                           void* userdata, sd_bus_error* ret_error) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    if (std::strcmp(property, "Category") == 0)
        return sd_bus_message_append(reply, "s", "ApplicationStatus");
 
    if (std::strcmp(property, "Id") == 0)
        return sd_bus_message_append(reply, "s", self->id_.c_str());
 
    if (std::strcmp(property, "Title") == 0)
        return sd_bus_message_append(reply, "s", self->title_.c_str());
 
    if (std::strcmp(property, "Status") == 0)
        return sd_bus_message_append(reply, "s", self->status_.c_str());
 
    if (std::strcmp(property, "IconName") == 0) {
        if (self->have_pixmap_)
            return sd_bus_message_append(reply, "s", "");
        return sd_bus_message_append(reply, "s", self->icon_name_.c_str());
    }
 
    if (std::strcmp(property, "IconPixmap") == 0) {
        int r = sd_bus_message_open_container(reply, 'a', "(iiay)");
        if (r < 0) return r;
 
        if (self->have_pixmap_ && self->pix_w_ > 0 && self->pix_h_ > 0
            && !self->pix_rgba_.empty())
        {
            r = sd_bus_message_open_container(reply, 'r', "iiay");
            if (r < 0) return r;
 
            r = sd_bus_message_append(reply, "ii", self->pix_w_, self->pix_h_);
            if (r < 0) return r;
 
            r = sd_bus_message_append_array(reply, 'y',
                                            self->pix_rgba_.data(),
                                            self->pix_rgba_.size());
            if (r < 0) return r;
 
            r = sd_bus_message_close_container(reply);
            if (r < 0) return r;
        }
 
        return sd_bus_message_close_container(reply);
    }
 
    if (std::strcmp(property, "Menu") == 0)
        return sd_bus_message_append(reply, "o", "/Menu");
 
    if (std::strcmp(property, "ToolTip") == 0) {
        int r = sd_bus_message_open_container(reply, 'r', "sa(iiay)ss");
        if (r < 0) return r;
 
        r = sd_bus_message_append(reply, "s", self->icon_name_.c_str());
        if (r < 0) return r;
 
        r = sd_bus_message_open_container(reply, 'a', "(iiay)");
        if (r < 0) return r;
        r = sd_bus_message_close_container(reply);
        if (r < 0) return r;
 
        r = sd_bus_message_append(reply, "s", self->title_.c_str());
        if (r < 0) return r;
        r = sd_bus_message_append(reply, "s", self->tooltip_.c_str());
        if (r < 0) return r;
 
        r = sd_bus_message_close_container(reply);
        if (r < 0) return r;
        return 0;
    }
 
    return sd_bus_error_setf(ret_error, SD_BUS_ERROR_UNKNOWN_PROPERTY,
                             "Unknown property '%s'", property);
}
 
int TrayIcon::dbusmenu_prop_get(sd_bus*, const char*, const char*,
                                const char* /*property*/, sd_bus_message* reply,
                                void*, sd_bus_error*) {
    return sd_bus_message_append(reply, "u", 3u);
}
 
static int append_menu_item(sd_bus_message* m, int id,
                            const char* label, bool enabled = true) {
    int r = 0;
    r = sd_bus_message_open_container(m, 'r', "ia{sv}av"); if (r < 0) return r;
    r = sd_bus_message_append(m, "i", id);                 if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'a', "{sv}");     if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'e', "sv");       if (r < 0) return r;
    r = sd_bus_message_append(m, "s", "label");            if (r < 0) return r;
    r = sd_bus_message_open_container(m, 'v', "s");        if (r < 0) return r;
    r = sd_bus_message_append(m, "s", label);              if (r < 0) return r;
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'e', "sv");       if (r < 0) return r;
    r = sd_bus_message_append(m, "s", "enabled");          if (r < 0) return r;
    r = sd_bus_message_open_container(m, 'v', "b");        if (r < 0) return r;
    r = sd_bus_message_append(m, "b", enabled ? 1 : 0);   if (r < 0) return r;
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
 
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'a', "v");        if (r < 0) return r;
    r = sd_bus_message_close_container(m);                 if (r < 0) return r;
 
    return sd_bus_message_close_container(m);
}
 
static int append_item_properties(sd_bus_message* m, int id,
                                   const char* label, bool enabled) {
    int r = 0;
    r = sd_bus_message_open_container(m, 'r', "ia{sv}"); if (r < 0) return r;
    r = sd_bus_message_append(m, "i", id);               if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'a', "{sv}");   if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'e', "sv");     if (r < 0) return r;
    r = sd_bus_message_append(m, "s", "label");          if (r < 0) return r;
    r = sd_bus_message_open_container(m, 'v', "s");      if (r < 0) return r;
    r = sd_bus_message_append(m, "s", label);            if (r < 0) return r;
    r = sd_bus_message_close_container(m);               if (r < 0) return r;
    r = sd_bus_message_close_container(m);               if (r < 0) return r;
 
    r = sd_bus_message_open_container(m, 'e', "sv");     if (r < 0) return r;
    r = sd_bus_message_append(m, "s", "enabled");        if (r < 0) return r;
    r = sd_bus_message_open_container(m, 'v', "b");      if (r < 0) return r;
    r = sd_bus_message_append(m, "b", enabled ? 1 : 0); if (r < 0) return r;
    r = sd_bus_message_close_container(m);               if (r < 0) return r;
    r = sd_bus_message_close_container(m);               if (r < 0) return r;
 
    r = sd_bus_message_close_container(m);               if (r < 0) return r;
    return sd_bus_message_close_container(m);
}
 
int TrayIcon::dbusmenu_method_get_status(sd_bus_message* m, void*, sd_bus_error*) {
    return sd_bus_reply_method_return(m, "s", "normal");
}
 
int TrayIcon::dbusmenu_method_get_children(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    int32_t parent = 0;
    int r = sd_bus_message_read(m, "i", &parent);
    if (r < 0) return r;
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    r = sd_bus_message_open_container(reply, 'a', "i");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    if (parent == MENU_ROOT) {
        int32_t ids[] = { MENU_SHOW, MENU_SETTINGS, MENU_QUIT };
        for (int32_t id : ids) {
            r = sd_bus_message_append(reply, "i", id);
            if (r < 0) { sd_bus_message_unref(reply); return r; }
        }
    }
 
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}
 
int TrayIcon::dbusmenu_method_get_layout(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    int32_t parent_id = 0, depth = 0;
    int r = sd_bus_message_read(m, "ii", &parent_id, &depth);
    if (r < 0) return r;
 
    r = sd_bus_message_skip(m, "as");
    if (r < 0) return r;
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    r = sd_bus_message_append(reply, "u", (uint32_t)1);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_open_container(reply, 'r', "ia{sv}av");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_append(reply, "i", MENU_ROOT);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_open_container(reply, 'a', "{sv}");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_open_container(reply, 'a', "v");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    bool include_children = (depth != 0);
 
    if (include_children) {
        auto push_child = [&](int id) -> int {
            int rr = sd_bus_message_open_container(reply, 'v', "(ia{sv}av)");
            if (rr < 0) return rr;
            rr = append_menu_item(reply, id,
                                  label_for_menu_id(id),
                                  enabled_for_menu_id(id));
            if (rr < 0) return rr;
            return sd_bus_message_close_container(reply);
        };
        r = push_child(MENU_SHOW);     if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = push_child(MENU_SETTINGS); if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = push_child(MENU_QUIT);     if (r < 0) { sd_bus_message_unref(reply); return r; }
    }
 
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}
 
int TrayIcon::dbusmenu_method_event(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    int32_t id = 0;
    const char* event_id_c = nullptr;
 
    int r = sd_bus_message_read(m, "is", &id, &event_id_c);
    if (r < 0)
        return sd_bus_reply_method_return(m, "");
 
    std::string ev = event_id_c ? event_id_c : "";
 
    (void)sd_bus_message_skip(m, "vu");
 
    std::fprintf(stderr, "[TrayIcon] Event: id=%d ev='%s'\n", (int)id, ev.c_str());
 
    if (!self->ui_ctx_) {
        std::fprintf(stderr, "[TrayIcon] WARNING: ui_ctx_ null (bind_ui_context?)\n");
        return sd_bus_reply_method_return(m, "");
    }
 
    g_main_context_invoke(self->ui_ctx_, invoke_std_function,
        new std::function<void()>([self, id]() {
            std::fprintf(stderr, "[TrayIcon] Dispatch on UI: id=%d\n", (int)id);
 
            if (id == MENU_SHOW) {
                if (self->on_activate_cb_) self->on_activate_cb_();
            } else if (id == MENU_SETTINGS) {
                if (self->on_settings_cb_) self->on_settings_cb_();
            } else if (id == MENU_QUIT) {
                if (self->on_quit_cb_) self->on_quit_cb_();
            } else {
                std::fprintf(stderr, "[TrayIcon] Unknown menu id=%d\n", (int)id);
            }
        })
    );
 
    return sd_bus_reply_method_return(m, "");
}
 
int TrayIcon::dbusmenu_method_about_to_show(sd_bus_message* m, void*, sd_bus_error*) {
    int32_t id = 0;
    int r = sd_bus_message_read(m, "i", &id);
    if (r < 0) return r;
    return sd_bus_reply_method_return(m, "b", 0);
}
 
int TrayIcon::dbusmenu_method_get_group_properties(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    int r = sd_bus_message_enter_container(m, 'a', "i");
    if (r < 0) return r;
 
    std::vector<int32_t> ids;
    for (;;) {
        int32_t id = 0;
        r = sd_bus_message_read(m, "i", &id);
        if (r < 0) return r;
        if (r == 0) break;
        ids.push_back(id);
    }
 
    r = sd_bus_message_exit_container(m);
    if (r < 0) return r;
 
    r = sd_bus_message_skip(m, "as");
    if (r < 0) return r;
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    r = sd_bus_message_open_container(reply, 'a', "(ia{sv})");
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    for (auto id : ids) {
        r = append_item_properties(reply, id,
                                   label_for_menu_id(id),
                                   enabled_for_menu_id(id));
        if (r < 0) { sd_bus_message_unref(reply); return r; }
    }
 
    r = sd_bus_message_close_container(reply);
    if (r < 0) { sd_bus_message_unref(reply); return r; }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}
 
int TrayIcon::dbusmenu_method_get_property(sd_bus_message* m, void* userdata, sd_bus_error*) {
    auto* self = static_cast<TrayIcon*>(userdata);
 
    int32_t     id   = 0;
    const char* prop = nullptr;
    int r = sd_bus_message_read(m, "is", &id, &prop);
    if (r < 0) return r;
 
    std::string prop_str = prop ? prop : "";
 
    sd_bus_message* reply = nullptr;
    r = sd_bus_message_new_method_return(m, &reply);
    if (r < 0) return r;
 
    if (prop_str == "label") {
        r = sd_bus_message_open_container(reply, 'v', "s");
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_append(reply, "s", label_for_menu_id(id));
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_close_container(reply);
        if (r < 0) { sd_bus_message_unref(reply); return r; }
    } else if (prop_str == "enabled") {
        r = sd_bus_message_open_container(reply, 'v', "b");
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_append(reply, "b", enabled_for_menu_id(id) ? 1 : 0);
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_close_container(reply);
        if (r < 0) { sd_bus_message_unref(reply); return r; }
    } else {
        r = sd_bus_message_open_container(reply, 'v', "s");
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_append(reply, "s", "");
        if (r < 0) { sd_bus_message_unref(reply); return r; }
        r = sd_bus_message_close_container(reply);
        if (r < 0) { sd_bus_message_unref(reply); return r; }
    }
 
    sd_bus* bus = sd_bus_message_get_bus(m);
    r = sd_bus_send(bus, reply, nullptr);
    sd_bus_message_unref(reply);
    return (r < 0) ? r : 1;
}