sndbusmenu.c (18596B) - View raw
#include "sndbusmenu.h" #include <stdlib.h> #include <stdio.h> #include <stdint.h> #include <string.h> #include <time.h> #include <glib.h> #include <glib-object.h> #include <gio/gio.h> #include "snitem.h" struct _SnDbusmenu { GObject parent_instance; char* busname; char* busobj; SnItem* snitem; GMenu* menu; GSimpleActionGroup* actiongroup; GDBusProxy* proxy; uint32_t revision; gboolean update_pending; gboolean reschedule; }; G_DEFINE_FINAL_TYPE(SnDbusmenu, sn_dbusmenu, G_TYPE_OBJECT) enum { PROP_BUSNAME=1, PROP_BUSOBJ, PROP_SNITEM, PROP_PROXY, N_PROPERTIES }; enum { ABOUT_TO_SHOW_HANDLED, LAST_SIGNAL }; #define ACTION_NAME_MAX_LEN 32 static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static unsigned int signals[LAST_SIGNAL]; static const char actiongroup_pfx[] = "menuitem"; static const int layout_update_freq = 80; typedef struct { uint32_t id; GDBusProxy* proxy; } ActionCallbackData; static void sn_dbusmenu_constructed (GObject *object); static void sn_dbusmenu_dispose (GObject *object); static void sn_dbusmenu_finalize (GObject *object); static void sn_dbusmenu_get_property (GObject *object, unsigned int property_id, GValue *value, GParamSpec *pspec); static void sn_dbusmenu_set_property (GObject *object, unsigned int property_id, const GValue *value, GParamSpec *pspec); static GMenu* create_menumodel (GVariant *data, SnDbusmenu *self); static GMenuItem* create_menuitem (int32_t id, GVariant *menu_data, GVariant *submenu_data, SnDbusmenu *self); static void action_activated_handler(GSimpleAction *action, GVariant* param, ActionCallbackData *data) { g_dbus_proxy_call(data->proxy, "Event", g_variant_new("(isvu)", data->id, "clicked", g_variant_new_string(""), time(NULL)), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); } static void action_free(void *data, GClosure *closure) { ActionCallbackData *acbd = (ActionCallbackData *)data; g_free(acbd); } static GSimpleAction* create_action(uint32_t id, gboolean ischeckmark, SnDbusmenu *self) { GSimpleAction *action; char name[ACTION_NAME_MAX_LEN]; sprintf(name, "%u", id); if (ischeckmark) action = g_simple_action_new_stateful(name, NULL, g_variant_new("b", TRUE)); else action = g_simple_action_new(name, NULL); ActionCallbackData *data = g_malloc(sizeof(ActionCallbackData)); data->id = id; data->proxy = self->proxy; g_signal_connect_data(action, "activate", G_CALLBACK(action_activated_handler), data, action_free, G_CONNECT_DEFAULT); return action; } static GMenuItem* create_menuitem(int32_t id, GVariant *menuitem_data, GVariant *submenuitem_data, SnDbusmenu *self) { GActionMap *actionmap = G_ACTION_MAP(self->actiongroup); char detailed_name[ACTION_NAME_MAX_LEN]; const char *label = NULL; const char *type_s = NULL; const char *toggle_type_s = NULL; const char *has_submenu_s = NULL; gboolean isenabled = TRUE; gboolean isvisible = TRUE; gboolean isseparator = FALSE; gboolean ischeckmark = FALSE; gboolean has_submenu = FALSE; // gboolean isradio = FALSE; gboolean checkmark_toggle_state = TRUE; GVariantDict dict; g_variant_dict_init(&dict, menuitem_data); g_variant_dict_lookup(&dict, "label", "&s", &label); g_variant_dict_lookup(&dict, "type", "&s", &type_s); g_variant_dict_lookup(&dict, "enabled", "b", &isenabled); g_variant_dict_lookup(&dict, "visible", "b", &isvisible); g_variant_dict_lookup(&dict, "children-display", "&s", &has_submenu_s); g_variant_dict_lookup(&dict, "toggle-type", "&s", &toggle_type_s); g_variant_dict_lookup(&dict, "toggle-state", "i", &checkmark_toggle_state); g_variant_dict_clear(&dict); if (has_submenu_s && strcmp(has_submenu_s, "submenu") == 0) has_submenu = TRUE; if (type_s && strcmp(type_s, "separator") == 0) isseparator = TRUE; else if (toggle_type_s && strcmp(toggle_type_s, "checkmark") == 0) ischeckmark = TRUE; /* else if (toggle_type_s && strcmp(toggle_type_s, "radio") == 0) isradio = TRUE; */ if (!isvisible || isseparator) return NULL; GSimpleAction *action = create_action(id, ischeckmark, self); sprintf(detailed_name, "%s.%u", actiongroup_pfx, id); GMenuItem *menuitem = g_menu_item_new(label, detailed_name); if (!isenabled) g_simple_action_set_enabled(action, FALSE); if (ischeckmark) g_simple_action_set_state(action, g_variant_new("b", checkmark_toggle_state)); if (has_submenu) { GMenu *submenu = create_menumodel(submenuitem_data, self); g_menu_item_set_submenu(menuitem, G_MENU_MODEL(submenu)); g_object_unref(submenu); } g_action_map_add_action(actionmap, G_ACTION(action)); g_object_unref(action); return menuitem; } static GMenu* create_menumodel(GVariant *data, SnDbusmenu *self) { GMenu *ret = g_menu_new(); GVariantIter iter; // (ia{sv}av) GVariant *menuitem_data_packed; GVariant *menuitem_data; int32_t id; g_variant_iter_init(&iter, data); while ((g_variant_iter_next(&iter, "v", &menuitem_data_packed))) { g_variant_get_child(menuitem_data_packed, 0, "i", &id); menuitem_data = g_variant_get_child_value(menuitem_data_packed, 1); GVariant *submenu_data = g_variant_get_child_value(menuitem_data_packed, 2); GMenuItem *menuitem = create_menuitem(id, menuitem_data, submenu_data, self); if (menuitem) { g_menu_append_item(ret, menuitem); g_object_unref(menuitem); } g_variant_unref(submenu_data); g_variant_unref(menuitem_data); g_variant_unref(menuitem_data_packed); } return ret; } static void layout_update_finish(GObject *obj, GAsyncResult *res, void *udata) { SnDbusmenu *self = SN_DBUSMENU(udata); GError *err = NULL; GVariant *data = g_dbus_proxy_call_finish(self->proxy, res, &err); if (err) { g_debug("Error in layout_update %s", err->message); g_error_free(err); g_object_unref(self->snitem); g_object_unref(self); return; } GVariant *layout; GVariant *menuitems; layout = g_variant_get_child_value(data, 1); menuitems = g_variant_get_child_value(layout, 2); gboolean isvisible = sn_item_get_popover_visible(self->snitem); if (isvisible) { self->reschedule = TRUE; g_debug("Popover was visible, couldn't update menu %s", self->busname); } else { GSimpleActionGroup *newag = g_simple_action_group_new(); sn_item_set_actiongroup(self->snitem, actiongroup_pfx, newag); g_object_unref(self->actiongroup); self->actiongroup = newag; GMenu *newmenu = create_menumodel(menuitems, self); sn_item_set_menu_model(self->snitem, newmenu); g_object_unref(self->menu); self->menu = newmenu; } g_variant_unref(menuitems); g_variant_unref(layout); g_variant_unref(data); g_object_unref(self->snitem); g_object_unref(self); } static void layout_update(SnDbusmenu *self) { g_debug("%s running menu layout update", self->busname); self->update_pending = FALSE; g_dbus_proxy_call(self->proxy, "GetLayout", g_variant_new("(iias)", 0, -1, NULL), G_DBUS_CALL_FLAGS_NONE, -1, NULL, layout_update_finish, self); } static void reschedule_update(SnItem *snitem, GParamSpec *pspec, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); g_return_if_fail(SN_IS_ITEM(self->snitem)); gboolean popover_visible = sn_item_get_popover_visible(snitem); if (popover_visible || !self->reschedule) return; g_debug("%s rescheduling layout update", self->busname); self->reschedule = FALSE; g_object_ref(self); g_object_ref(self->snitem); layout_update(self); } // Update signals are often received multiple times in row, // we throttle update frequency to *layout_update_freq* static void proxy_signal_handler(GDBusProxy *proxy, const char *sender, const char *signal, GVariant *params, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); g_return_if_fail(SN_IS_ITEM(self->snitem)); if (strcmp(signal, "LayoutUpdated") == 0) { uint32_t revision; int32_t parentid; g_variant_get(params, "(ui)", &revision, &parentid); g_debug("%s got LayoutUpdated, revision %i, parentid %i", self->busname, revision, parentid); if (self->revision == UINT32_MAX || self->revision < revision) { self->revision = revision; } if (!self->update_pending) { self->update_pending = TRUE; g_object_ref(self->snitem); g_timeout_add_once(layout_update_freq, (GSourceOnceFunc)layout_update, g_object_ref(self)); } else { g_debug("skipping update"); } } else if (strcmp(signal, "ItemsPropertiesUpdated") == 0) { g_debug("%s got ItemsPropertiesUpdated", self->busname); if (!self->update_pending) { self->update_pending = TRUE; g_object_ref(self->snitem); g_timeout_add_once(layout_update_freq, (GSourceOnceFunc)layout_update, g_object_ref(self)); } else { g_debug("skipping update"); } } } static void menulayout_ready_handler(GObject *obj, GAsyncResult *res, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); GError *err = NULL; GVariant *retvariant = g_dbus_proxy_call_finish(self->proxy, res, &err); // (u(ia{sv}av)) // "No such object path '/NO_DBUSMENU'" // generated by QBittorrent when it sends a broken trayitem on startup // and replaces it later if (err && g_error_matches(err, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_OBJECT)) { g_error_free(err); g_object_unref(self); return; } else if (err) { g_warning("%s\n", err->message); g_error_free(err); g_object_unref(self); return; } uint32_t revision = 0; GVariant *layout; GVariant *menuitems; g_variant_get_child(retvariant, 0, "u", &revision); layout = g_variant_get_child_value(retvariant, 1); menuitems = g_variant_get_child_value(layout, 2); self->menu = create_menumodel(menuitems, self); sn_item_set_menu_model(self->snitem, self->menu); g_variant_unref(menuitems); g_variant_unref(layout); g_variant_unref(retvariant); g_object_unref(self); } static void about_to_show_timeout_handler(void *data) { SnDbusmenu *self = SN_DBUSMENU(data); g_signal_emit(self, signals[ABOUT_TO_SHOW_HANDLED], 0); g_object_unref(self); } static void about_to_show_handler(GObject *obj, GAsyncResult *res, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); GError *err = NULL; GVariant *val = g_dbus_proxy_call_finish(self->proxy, res, &err); // I give up trying to get nm-applet working properly. Wait 2 seconds until popping the menu // to let it finish its business. int timeout; if (strcmp(self->busobj, "/org/ayatana/NotificationItem/nm_applet/Menu" ) == 0) { timeout = 2000; } else { timeout = 100; } // Discord generates the following error here: // 'G_DBUS_ERROR' 'G_DBUS_ERROR_FAILED' 'error occurred in AboutToShow' // We ignore it. if (err && !g_error_matches(err, G_DBUS_ERROR, G_DBUS_ERROR_FAILED) && g_strrstr(err->message, "error occured in AboutToShow") != 0) { g_warning("%s\n", err->message); } else { // This dbusmenu call might have triggered a menu update, g_timeout_add_once(timeout, about_to_show_timeout_handler, g_object_ref(self)); } err ? g_error_free(err) : g_variant_unref(val); g_object_unref(self); } static void rightclick_handler(GObject *obj, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); g_assert(SN_IS_DBUSMENU(self)); g_dbus_proxy_call(self->proxy, "AboutToShow", g_variant_new("(i)", 0), G_DBUS_CALL_FLAGS_NONE, -1, NULL, about_to_show_handler, g_object_ref(self)); } static void proxy_ready_handler(GObject *obj, GAsyncResult *res, void *data) { SnDbusmenu *self = SN_DBUSMENU(data); GError *err = NULL; GDBusProxy *proxy = g_dbus_proxy_new_for_bus_finish(res, &err); if (err) { g_warning("Failed to construct gdbusproxy for menu: %s\n", err->message); g_error_free(err); g_object_unref(self); return; } g_debug("Created gdbusproxy for menu %s %s", g_dbus_proxy_get_name(proxy), g_dbus_proxy_get_object_path(proxy)); g_object_set(self, "proxy", proxy, NULL); g_dbus_proxy_call(self->proxy, "GetLayout", g_variant_new ("(iias)", 0, -1, NULL), G_DBUS_CALL_FLAGS_NONE, -1, NULL, menulayout_ready_handler, g_object_ref(self)); g_signal_connect(self->proxy, "g-signal", G_CALLBACK(proxy_signal_handler), self); g_object_unref(self); } static void sn_dbusmenu_get_property(GObject *object, unsigned int property_id, GValue *value, GParamSpec *pspec) { G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); } static void sn_dbusmenu_set_property(GObject *object, unsigned int property_id, const GValue *value, GParamSpec *pspec) { SnDbusmenu *self = SN_DBUSMENU(object); switch (property_id) { case PROP_BUSNAME: self->busname = g_strdup(g_value_get_string(value)); break; case PROP_BUSOBJ: self->busobj = g_strdup(g_value_get_string(value)); break; case PROP_SNITEM: self->snitem = g_value_get_object(value); break; case PROP_PROXY: self->proxy = g_value_get_object(value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } } static void sn_dbusmenu_class_init(SnDbusmenuClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->set_property = sn_dbusmenu_set_property; object_class->get_property = sn_dbusmenu_get_property; object_class->constructed = sn_dbusmenu_constructed; object_class->dispose = sn_dbusmenu_dispose; object_class->finalize = sn_dbusmenu_finalize; obj_properties[PROP_BUSNAME] = g_param_spec_string("busname", NULL, NULL, NULL, G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_BUSOBJ] = g_param_spec_string("busobj", NULL, NULL, NULL, G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_SNITEM] = g_param_spec_object("snitem", NULL, NULL, SN_TYPE_ITEM, G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_PROXY] = g_param_spec_object("proxy", NULL, NULL, G_TYPE_DBUS_PROXY, G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties(object_class, N_PROPERTIES, obj_properties); signals[ABOUT_TO_SHOW_HANDLED] = g_signal_new("abouttoshowhandled", SN_TYPE_DBUSMENU, G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); } static void sn_dbusmenu_init(SnDbusmenu *self) { // When reschedule is TRUE, menu will be updated next time it is closed. self->reschedule = FALSE; self->update_pending = FALSE; self->actiongroup = g_simple_action_group_new(); } static void sn_dbusmenu_constructed(GObject *obj) { SnDbusmenu *self = SN_DBUSMENU(obj); sn_item_set_actiongroup(self->snitem, actiongroup_pfx, self->actiongroup); GDBusNodeInfo *nodeinfo = g_dbus_node_info_new_for_xml(DBUSMENU_XML, NULL); g_dbus_proxy_new_for_bus(G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, nodeinfo->interfaces[0], self->busname, self->busobj, "com.canonical.dbusmenu", NULL, (GAsyncReadyCallback)proxy_ready_handler, g_object_ref(self)); g_dbus_node_info_unref(nodeinfo); g_signal_connect(self->snitem, "notify::menuvisible", G_CALLBACK(reschedule_update), self); g_signal_connect(self->snitem, "rightclick", G_CALLBACK(rightclick_handler), self); G_OBJECT_CLASS(sn_dbusmenu_parent_class)->constructed(obj); } static void sn_dbusmenu_dispose(GObject *obj) { SnDbusmenu *self = SN_DBUSMENU(obj); g_debug("Disposing sndbusmenu %s %s", self->busname, self->busobj); if (self->proxy) { g_object_unref(self->proxy); self->proxy = NULL; } if (self->actiongroup) { sn_item_clear_actiongroup(self->snitem, actiongroup_pfx); g_object_unref(self->actiongroup); self->actiongroup = NULL; } if (self->menu) { sn_item_clear_menu_model(self->snitem); g_object_unref(self->menu); self->menu = NULL; } if (self->snitem) { g_object_unref(self->snitem); self->snitem = NULL; } G_OBJECT_CLASS(sn_dbusmenu_parent_class)->dispose(obj); } static void sn_dbusmenu_finalize(GObject *obj) { SnDbusmenu *self = SN_DBUSMENU(obj); g_free(self->busname); g_free(self->busobj); G_OBJECT_CLASS(sn_dbusmenu_parent_class)->finalize(obj); } SnDbusmenu* sn_dbusmenu_new(const char *busname, const char *busobj, SnItem *snitem) { return g_object_new(SN_TYPE_DBUSMENU, "busname", busname, "busobj", busobj, "snitem", snitem, NULL); }