static DbusmenuMenuitem * progress_ui_handler_build_unity_quicklist (NemoProgressUIHandler *self) { g_return_if_fail (self); GList *l; for (l = unity_quicklist_get_launcher_entries (self->priv->unity_quicklist_handler); l; l = l->next) { UnityLauncherEntry *entry = l->data; DbusmenuMenuitem *quickmenu = dbusmenu_menuitem_new (); dbusmenu_menuitem_property_set (quickmenu, DBUSMENU_MENUITEM_PROP_LABEL, UNITY_QUICKLIST_SHOW_COPY_DIALOG); dbusmenu_menuitem_property_set_bool (quickmenu, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE); unity_quicklist_handler_append_menuitem (entry, quickmenu); g_signal_connect (quickmenu, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) progress_ui_handler_unity_quicklist_show_activated, self); quickmenu = dbusmenu_menuitem_new (); dbusmenu_menuitem_property_set (quickmenu, DBUSMENU_MENUITEM_PROP_LABEL, UNITY_QUICKLIST_CANCEL_COPY); dbusmenu_menuitem_property_set_bool (quickmenu, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE); unity_quicklist_handler_append_menuitem (entry, quickmenu); g_signal_connect (quickmenu, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) progress_ui_handler_unity_quicklist_cancel_activated, self); } }
static GObject * playlists_menuitem_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { GObject * obj; GObjectClass * parent_class; PlaylistsMenuitem * self; GeeHashMap* _tmp0_; DbusmenuMenuitem* _tmp1_; DbusmenuMenuitem* _tmp2_; const gchar* _tmp3_ = NULL; DbusmenuMenuitem* _tmp4_; parent_class = G_OBJECT_CLASS (playlists_menuitem_parent_class); obj = parent_class->constructor (type, n_construct_properties, construct_properties); self = PLAYLISTS_MENUITEM (obj); _tmp0_ = gee_hash_map_new (G_TYPE_INT, NULL, NULL, dbusmenu_menuitem_get_type (), (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL); _g_object_unref0 (self->priv->current_playlists); self->priv->current_playlists = _tmp0_; _tmp1_ = dbusmenu_menuitem_new (); _g_object_unref0 (self->root_item); self->root_item = _tmp1_; _tmp2_ = self->root_item; _tmp3_ = _ ("Choose Playlist"); dbusmenu_menuitem_property_set (_tmp2_, DBUSMENU_MENUITEM_PROP_LABEL, _tmp3_); _tmp4_ = self->root_item; dbusmenu_menuitem_property_set (_tmp4_, DBUSMENU_PLAYLIST_MENUITEM_PATH, ""); return obj; }
static void unity_bookmarks_handler_update_bookmarks () { NemoBookmark *bookmark; guint bookmark_count; guint index; GList *l; /* append new set of bookmarks */ bookmark_count = nemo_bookmark_list_length (bookmarks); for (index = 0; index < bookmark_count; ++index) { bookmark = nemo_bookmark_list_item_at (bookmarks, index); if (nemo_bookmark_uri_known_not_to_exist (bookmark)) { continue; } for (l = unity_quicklist_get_launcher_entries (unity_quicklist_handler); l; l = l->next) { UnityLauncherEntry *entry = l->data; DbusmenuMenuitem* menuitem = dbusmenu_menuitem_new(); gchar *bookmark_name_dbusmenu = eel_str_replace_substring (nemo_bookmark_get_name (bookmark), "_", "__"); dbusmenu_menuitem_property_set (menuitem, "label", bookmark_name_dbusmenu); g_free (bookmark_name_dbusmenu); g_signal_connect (menuitem, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, (GCallback) activate_bookmark_by_quicklist, bookmark); unity_quicklist_handler_append_menuitem (entry, menuitem); } } }
/* Build the inital status items and start kicking off the async code for handling all the statuses */ GList * status_items_build (StatusUpdateFunc status_update_func) { int i; for (i = STATUS_PROVIDER_STATUS_ONLINE; i < STATUS_PROVIDER_STATUS_DISCONNECTED; i++) { DbusmenuMenuitem * item = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_LABEL, _(status_strings[i])); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_ICON_NAME, status_icons[i]); dbusmenu_menuitem_property_set_bool(item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE); dbusmenu_menuitem_property_set_bool(item, DBUSMENU_MENUITEM_PROP_ENABLED, FALSE); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_RADIO); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED); g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(user_status_change), GINT_TO_POINTER(i)); menuitems = g_list_append(menuitems, item); } update_func = status_update_func; const gchar * status_providers_env = g_getenv("INDICATOR_MESSAGES_STATUS_PROVIDER_DIR"); if (status_providers_env == NULL) { g_idle_add(provider_directory_parse, STATUS_PROVIDER_DIR); } else { g_idle_add(provider_directory_parse, (gpointer)status_providers_env); } return menuitems; }
DbusmenuMenuitem *addMenuItem(DbusmenuMenuitem *parent, int uid, const char * label, int type, int position) { // _logmsg(LOG_LEVEL_INFO, "add menu item %s (%d) [p %s]", label, uid, _getItemLabel(parent)); DbusmenuMenuitem *item = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set_int(item, MENUITEM_UID_PROPERTY, uid); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_LABEL, label); if (type == ITEM_SUBMENU) dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY, DBUSMENU_MENUITEM_CHILD_DISPLAY_SUBMENU); else if (type == ITEM_CHECK) dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_CHECK); else if (type == ITEM_RADIO) dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_RADIO); dbusmenu_menuitem_property_set_bool(item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE); g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_EVENT, G_CALLBACK(_onItemEvent), NULL); g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_ABOUT_TO_SHOW, G_CALLBACK(_onItemAboutToShow), NULL); // g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_SHOW_TO_USER, G_CALLBACK(_onItemShowToUser), NULL); g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(_onItemActivated), NULL); // g_signal_connect(G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_CHILD_ADDED, G_CALLBACK(_onItemChildAdded), NULL); if (parent != NULL) { gpointer data = g_object_get_data(G_OBJECT(parent), MENUITEM_JHANDLER_PROPERTY); if (data == NULL) _logmsg(LOG_LEVEL_ERROR, "parent of item %d hasn't jhandler", uid); g_object_set_data(G_OBJECT(item), MENUITEM_JHANDLER_PROPERTY, data); if (position < 0) dbusmenu_menuitem_child_append(parent, item); else dbusmenu_menuitem_child_add_position(parent, item, (guint)position); } return item; }
DbusmenuMenuitem* addSeparator(DbusmenuMenuitem * parent, int uid, int position) { DbusmenuMenuitem* item = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(item, DBUSMENU_MENUITEM_PROP_TYPE, "separator"); dbusmenu_menuitem_property_set_int(item, MENUITEM_UID_PROPERTY, uid); dbusmenu_menuitem_property_set_bool(item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE); if (parent != NULL) { if (position < 0) dbusmenu_menuitem_child_append(parent, item); else dbusmenu_menuitem_child_add_position(parent, item, (guint)position); } return item; }
/* Main, is well, main. It brings everything up and throws us into the mainloop of no return. */ int main (int argc, char ** argv) { g_type_init(); /* Setting up i18n and gettext. Apparently, we need all of these. */ setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); textdomain (GETTEXT_PACKAGE); IndicatorService * service = indicator_service_new_version(INDICATOR_SESSION_DBUS_NAME, INDICATOR_SESSION_DBUS_VERSION); g_signal_connect(G_OBJECT(service), INDICATOR_SERVICE_SIGNAL_SHUTDOWN, G_CALLBACK(service_shutdown), NULL); session_dbus = session_dbus_new(); g_idle_add(lock_screen_setup, NULL); root_menuitem = dbusmenu_menuitem_new(); g_debug("Root ID: %d", dbusmenu_menuitem_get_id(root_menuitem)); dbus_interface = g_object_new (USERS_SERVICE_DBUS_TYPE, NULL); rebuild_items (root_menuitem, dbus_interface); g_signal_connect (G_OBJECT (dbus_interface), "user-added", G_CALLBACK (user_change), root_menuitem); g_signal_connect (G_OBJECT (dbus_interface), "user-removed", G_CALLBACK (user_change), root_menuitem); setup_restart_watch(); setup_up(); DbusmenuServer * server = dbusmenu_server_new(INDICATOR_SESSION_DBUS_OBJECT); dbusmenu_server_set_root(server, root_menuitem); mainloop = g_main_loop_new(NULL, FALSE); g_main_loop_run(mainloop); return 0; }
AbstractLauncherIcon::MenuItemsVector TrashLauncherIcon::GetMenus() { MenuItemsVector result; /* Empty Trash */ glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new()); dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Empty Trash…")); dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, !empty_); dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true); empty_activated_signal_.Connect(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) { file_manager_->EmptyTrash(timestamp); }); result.push_back(menu_item); return result; }
void createMenuRootForWnd(WndInfo *wi) { if (wi->menuroot != NULL) { _releaseMenuItem(wi->menuroot); wi->menuroot = NULL; } wi->menuroot = dbusmenu_menuitem_new(); if (wi->menuroot == NULL) { _error("can't create menuitem for new root"); return; } g_object_set_data(G_OBJECT(wi->menuroot), MENUITEM_JHANDLER_PROPERTY, wi->jhandler); dbusmenu_menuitem_property_set(wi->menuroot, DBUSMENU_MENUITEM_PROP_LABEL, "DBusMenuRoot"); if (wi->server == NULL) _error("can't set new root because wi->server is null"); else dbusmenu_server_set_root(wi->server, wi->menuroot); }
/* Builds up the menu for us */ static void rebuild_items (DbusmenuMenuitem *root, UsersServiceDbus *service) { DbusmenuMenuitem *mi = NULL; DbusmenuMenuitem * guest_mi = NULL; GList *u; UserData *user; gboolean can_activate; gboolean can_lockscreen; GList *children; /* Make sure we have a valid GConf client, and build one if needed */ ensure_gconf_client (); /* Check to see which menu items we're allowed to have */ can_activate = users_service_dbus_can_activate_session (service) && !gconf_client_get_bool (gconf_client, LOCKDOWN_KEY_USER, NULL); can_lockscreen = !gconf_client_get_bool (gconf_client, LOCKDOWN_KEY_SCREENSAVER, NULL); /* Remove the old menu items if that makes sense */ children = dbusmenu_menuitem_take_children (root); g_list_foreach (children, (GFunc)g_object_unref, NULL); g_list_free (children); /* Lock screen item */ if (can_lockscreen) { lock_menuitem = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(lock_menuitem, DBUSMENU_MENUITEM_PROP_LABEL, _("Lock Screen")); gchar * shortcut = gconf_client_get_string(gconf_client, KEY_LOCK_SCREEN, NULL); if (shortcut != NULL) { g_debug("Lock screen shortcut: %s", shortcut); dbusmenu_menuitem_property_set_shortcut_string(lock_menuitem, shortcut); g_free(shortcut); } else { g_debug("Unable to get lock screen shortcut."); } g_signal_connect(G_OBJECT(lock_menuitem), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(lock_screen), NULL); dbusmenu_menuitem_child_append(root, lock_menuitem); } /* Set to NULL just incase we don't end up building one */ users_service_dbus_set_guest_item(service, NULL); /* Build all of the user switching items */ if (can_activate == TRUE) { if (can_lockscreen) { DbusmenuMenuitem * separator1 = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(separator1, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR); dbusmenu_menuitem_child_append(root, separator1); } if (check_guest_session ()) { guest_mi = dbusmenu_menuitem_new (); dbusmenu_menuitem_property_set (guest_mi, DBUSMENU_MENUITEM_PROP_TYPE, USER_ITEM_TYPE); dbusmenu_menuitem_property_set (guest_mi, USER_ITEM_PROP_NAME, _("Guest Session")); dbusmenu_menuitem_property_set_bool (guest_mi, USER_ITEM_PROP_LOGGED_IN, FALSE); dbusmenu_menuitem_child_append (root, guest_mi); g_signal_connect (G_OBJECT (guest_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_guest_session), service); users_service_dbus_set_guest_item(service, guest_mi); } if (check_new_session ()) { switch_menuitem = dbusmenu_menuitem_new (); dbusmenu_menuitem_property_set (switch_menuitem, DBUSMENU_MENUITEM_PROP_TYPE, MENU_SWITCH_TYPE); dbusmenu_menuitem_property_set (switch_menuitem, MENU_SWITCH_USER, g_get_user_name()); dbusmenu_menuitem_child_append (root, switch_menuitem); g_signal_connect (G_OBJECT (switch_menuitem), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_new_session), NULL); } GList * users = NULL; users = users_service_dbus_get_user_list (service); guint user_count = g_list_length(users); if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) { users = g_list_sort (users, (GCompareFunc)compare_users_by_username); } for (u = users; u != NULL; u = g_list_next (u)) { user = u->data; user->service = service; if (user->uid == getuid()) { /* Hide me from the list */ continue; } if (g_strcmp0(user->user_name, "guest") == 0) { /* Check to see if the guest has sessions and so therefore should get a check mark. */ if (user->sessions != NULL) { dbusmenu_menuitem_property_set_bool (guest_mi, USER_ITEM_PROP_LOGGED_IN, TRUE); } /* If we're showing user accounts, keep going through the list */ if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) { continue; } /* If not, we can stop here */ break; } if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) { mi = dbusmenu_menuitem_new (); dbusmenu_menuitem_property_set (mi, DBUSMENU_MENUITEM_PROP_TYPE, USER_ITEM_TYPE); if (user->real_name_conflict) { gchar * conflictedname = g_strdup_printf("%s (%s)", user->real_name, user->user_name); dbusmenu_menuitem_property_set (mi, USER_ITEM_PROP_NAME, conflictedname); g_free(conflictedname); } else { dbusmenu_menuitem_property_set (mi, USER_ITEM_PROP_NAME, user->real_name); } dbusmenu_menuitem_property_set_bool (mi, USER_ITEM_PROP_LOGGED_IN, user->sessions != NULL); if (user->icon_url != NULL && user->icon_url[0] != '\0' && g_str_has_prefix(user->icon_url, "file://")) { dbusmenu_menuitem_property_set(mi, USER_ITEM_PROP_ICON, user->icon_url + strlen("file://")); } else { dbusmenu_menuitem_property_set(mi, USER_ITEM_PROP_ICON, USER_ITEM_ICON_DEFAULT); } dbusmenu_menuitem_child_append (root, mi); g_signal_connect (G_OBJECT (mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_user_session), user); user->menuitem = mi; } } g_list_free(users); } /* If there were a bunch of items before us, we need a separator. */ if (can_lockscreen || can_activate) { DbusmenuMenuitem * separator = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR); dbusmenu_menuitem_child_append(root, separator); } /* Start going through the session based items. */ logout_mi = dbusmenu_menuitem_new(); if (supress_confirmations()) { dbusmenu_menuitem_property_set(logout_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Log Out")); } else { dbusmenu_menuitem_property_set(logout_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Log Out\342\200\246")); } dbusmenu_menuitem_property_set_bool(logout_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_logout()); dbusmenu_menuitem_child_append(root, logout_mi); g_signal_connect(G_OBJECT(logout_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "logout"); if (can_suspend && allow_suspend) { suspend_mi = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(suspend_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Suspend")); dbusmenu_menuitem_child_append(root, suspend_mi); g_signal_connect(G_OBJECT(suspend_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(machine_sleep), "Suspend"); } if (can_hibernate && allow_hibernate) { hibernate_mi = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(hibernate_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Hibernate")); dbusmenu_menuitem_child_append(root, hibernate_mi); g_signal_connect(G_OBJECT(hibernate_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(machine_sleep), "Hibernate"); } restart_mi = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(restart_mi, DBUSMENU_MENUITEM_PROP_TYPE, RESTART_ITEM_TYPE); if (supress_confirmations()) { dbusmenu_menuitem_property_set(restart_mi, RESTART_ITEM_LABEL, _("Restart")); } else { dbusmenu_menuitem_property_set(restart_mi, RESTART_ITEM_LABEL, _("Restart\342\200\246")); } dbusmenu_menuitem_property_set_bool(restart_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_restart()); dbusmenu_menuitem_child_append(root, restart_mi); g_signal_connect(G_OBJECT(restart_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "restart"); shutdown_mi = dbusmenu_menuitem_new(); if (supress_confirmations()) { dbusmenu_menuitem_property_set(shutdown_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Shut Down")); } else { dbusmenu_menuitem_property_set(shutdown_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Shut Down\342\200\246")); } dbusmenu_menuitem_property_set_bool(shutdown_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_shutdown()); dbusmenu_menuitem_child_append(root, shutdown_mi); g_signal_connect(G_OBJECT(shutdown_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "shutdown"); RestartShutdownLogoutMenuItems * restart_shutdown_logout_mi = g_new0 (RestartShutdownLogoutMenuItems, 1); restart_shutdown_logout_mi->logout_mi = logout_mi; restart_shutdown_logout_mi->restart_mi = restart_mi; restart_shutdown_logout_mi->shutdown_mi = shutdown_mi; update_menu_entries(restart_shutdown_logout_mi); /* now add extra launchers */ GDir *extra_launchers_dir; extra_launchers_dir = g_dir_open (EXTRA_LAUNCHER_DIR, 0, NULL); if (extra_launchers_dir != NULL) { GList * launchers = NULL; /* Find all the desktop files we want to use */ for (;;) { const gchar *extra_launcher_file; extra_launcher_file = g_dir_read_name (extra_launchers_dir); if (extra_launcher_file == NULL) break; if (!g_str_has_suffix (extra_launcher_file, ".desktop")) continue; gchar *full_path = g_build_filename (EXTRA_LAUNCHER_DIR, extra_launcher_file, NULL); GAppInfo * appinfo = G_APP_INFO(g_desktop_app_info_new_from_filename (full_path)); g_free (full_path); launchers = g_list_prepend(launchers, appinfo); } g_dir_close(extra_launchers_dir); /* Sort the desktop files based on their names */ launchers = g_list_sort(launchers, sort_app_infos); /* Turn each one into a separate menu item */ GList * launcher = NULL; gboolean sepadded = FALSE; for (launcher = launchers; launcher != NULL; launcher = g_list_next(launcher)) { GAppInfo * appinfo = G_APP_INFO(launcher->data); /* Make sure we have a separator */ if (!sepadded) { DbusmenuMenuitem * separator = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR); dbusmenu_menuitem_child_append(root, separator); g_object_unref(separator); sepadded = TRUE; } /* Build the item */ DbusmenuMenuitem * desktop_mi = dbusmenu_menuitem_new(); dbusmenu_menuitem_property_set(desktop_mi, DBUSMENU_MENUITEM_PROP_LABEL, g_app_info_get_name(appinfo)); g_signal_connect(G_OBJECT(desktop_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(desktop_activate_cb), appinfo); g_object_weak_ref(G_OBJECT(desktop_mi), (GWeakNotify)g_object_unref, appinfo); /* Put into the menu */ dbusmenu_menuitem_child_append(root, desktop_mi); } g_list_free(launchers); } return; }
void playlists_menuitem_update (PlaylistsMenuitem* self, PlaylistDetails* playlists, int playlists_length1) { PlaylistDetails* _tmp0_; gint _tmp0__length1; g_return_if_fail (self != NULL); _tmp0_ = playlists; _tmp0__length1 = playlists_length1; { PlaylistDetails* detail_collection = NULL; gint detail_collection_length1 = 0; gint _detail_collection_size_ = 0; gint detail_it = 0; detail_collection = _tmp0_; detail_collection_length1 = _tmp0__length1; for (detail_it = 0; detail_it < _tmp0__length1; detail_it = detail_it + 1) { PlaylistDetails _tmp1_ = {0}; PlaylistDetails detail = {0}; playlist_details_copy (&detail_collection[detail_it], &_tmp1_); detail = _tmp1_; { Block2Data* _data2_; gboolean _tmp2_ = FALSE; PlaylistDetails _tmp3_; gboolean _tmp4_ = FALSE; gboolean _tmp7_; DbusmenuMenuitem* _tmp8_; DbusmenuMenuitem* _tmp9_; PlaylistDetails _tmp10_; const gchar* _tmp11_; gchar* _tmp12_ = NULL; gchar* _tmp13_; DbusmenuMenuitem* _tmp14_; DbusmenuMenuitem* _tmp15_; PlaylistDetails _tmp16_; const char* _tmp17_; DbusmenuMenuitem* _tmp18_; DbusmenuMenuitem* _tmp19_; DbusmenuMenuitem* _tmp20_; GeeHashMap* _tmp21_; DbusmenuMenuitem* _tmp22_; gint _tmp23_; gint _tmp24_; DbusmenuMenuitem* _tmp25_; DbusmenuMenuitem* _tmp26_; DbusmenuMenuitem* _tmp27_; PlaylistDetails _tmp28_; const gchar* _tmp29_; _data2_ = g_slice_new0 (Block2Data); _data2_->_ref_count_ = 1; _data2_->self = g_object_ref (self); _tmp3_ = detail; _tmp4_ = playlists_menuitem_already_observed (self, &_tmp3_); if (_tmp4_) { _tmp2_ = TRUE; } else { PlaylistDetails _tmp5_; gboolean _tmp6_ = FALSE; _tmp5_ = detail; _tmp6_ = playlists_menuitem_is_video_related (self, &_tmp5_); _tmp2_ = _tmp6_; } _tmp7_ = _tmp2_; if (_tmp7_) { playlist_details_destroy (&detail); block2_data_unref (_data2_); _data2_ = NULL; continue; } _tmp8_ = dbusmenu_menuitem_new (); _data2_->menuitem = _tmp8_; _tmp9_ = _data2_->menuitem; _tmp10_ = detail; _tmp11_ = _tmp10_.name; _tmp12_ = playlists_menuitem_truncate_item_label_if_needs_be (self, _tmp11_); _tmp13_ = _tmp12_; dbusmenu_menuitem_property_set (_tmp9_, DBUSMENU_MENUITEM_PROP_LABEL, _tmp13_); _g_free0 (_tmp13_); _tmp14_ = _data2_->menuitem; dbusmenu_menuitem_property_set (_tmp14_, DBUSMENU_MENUITEM_PROP_ICON_NAME, "playlist-symbolic"); _tmp15_ = _data2_->menuitem; _tmp16_ = detail; _tmp17_ = _tmp16_.path; dbusmenu_menuitem_property_set (_tmp15_, DBUSMENU_PLAYLIST_MENUITEM_PATH, (const gchar*) _tmp17_); _tmp18_ = _data2_->menuitem; dbusmenu_menuitem_property_set_bool (_tmp18_, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE); _tmp19_ = _data2_->menuitem; dbusmenu_menuitem_property_set_bool (_tmp19_, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE); _tmp20_ = _data2_->menuitem; g_signal_connect_data (_tmp20_, "item-activated", (GCallback) _____lambda3__dbusmenu_menuitem_item_activated, block2_data_ref (_data2_), (GClosureNotify) block2_data_unref, 0); _tmp21_ = self->priv->current_playlists; _tmp22_ = _data2_->menuitem; _tmp23_ = dbusmenu_menuitem_get_id (_tmp22_); _tmp24_ = _tmp23_; _tmp25_ = _data2_->menuitem; gee_abstract_map_set ((GeeAbstractMap*) _tmp21_, GINT_TO_POINTER (_tmp24_), _tmp25_); _tmp26_ = self->root_item; _tmp27_ = _data2_->menuitem; dbusmenu_menuitem_child_append (_tmp26_, _tmp27_); _tmp28_ = detail; _tmp29_ = _tmp28_.name; g_debug ("playlists-menu-item.vala:66: populating valid playlists %s", _tmp29_); playlist_details_destroy (&detail); block2_data_unref (_data2_); _data2_ = NULL; } } } { GeeHashMap* _tmp30_; GeeCollection* _tmp31_; GeeCollection* _tmp32_; GeeCollection* _tmp33_; GeeIterator* _tmp34_ = NULL; GeeIterator* _tmp35_; GeeIterator* _item_it; _tmp30_ = self->priv->current_playlists; _tmp31_ = gee_abstract_map_get_values ((GeeMap*) _tmp30_); _tmp32_ = _tmp31_; _tmp33_ = _tmp32_; _tmp34_ = gee_iterable_iterator ((GeeIterable*) _tmp33_); _tmp35_ = _tmp34_; _g_object_unref0 (_tmp33_); _item_it = _tmp35_; while (TRUE) { GeeIterator* _tmp36_; gboolean _tmp37_ = FALSE; GeeIterator* _tmp38_; gpointer _tmp39_ = NULL; DbusmenuMenuitem* item; gboolean within; PlaylistDetails* _tmp40_; gint _tmp40__length1; gboolean _tmp46_; _tmp36_ = _item_it; _tmp37_ = gee_iterator_next (_tmp36_); if (!_tmp37_) { break; } _tmp38_ = _item_it; _tmp39_ = gee_iterator_get (_tmp38_); item = (DbusmenuMenuitem*) _tmp39_; within = FALSE; _tmp40_ = playlists; _tmp40__length1 = playlists_length1; { PlaylistDetails* detail_collection = NULL; gint detail_collection_length1 = 0; gint _detail_collection_size_ = 0; gint detail_it = 0; detail_collection = _tmp40_; detail_collection_length1 = _tmp40__length1; for (detail_it = 0; detail_it < _tmp40__length1; detail_it = detail_it + 1) { PlaylistDetails _tmp41_ = {0}; PlaylistDetails detail = {0}; playlist_details_copy (&detail_collection[detail_it], &_tmp41_); detail = _tmp41_; { PlaylistDetails _tmp42_; const char* _tmp43_; DbusmenuMenuitem* _tmp44_; const gchar* _tmp45_ = NULL; _tmp42_ = detail; _tmp43_ = _tmp42_.path; _tmp44_ = item; _tmp45_ = dbusmenu_menuitem_property_get (_tmp44_, DBUSMENU_PLAYLIST_MENUITEM_PATH); if (g_strcmp0 (_tmp43_, _tmp45_) == 0) { within = TRUE; playlist_details_destroy (&detail); break; } playlist_details_destroy (&detail); } } } _tmp46_ = within; if (_tmp46_ == FALSE) { DbusmenuMenuitem* _tmp47_; const gchar* _tmp48_ = NULL; DbusmenuMenuitem* _tmp49_; const gchar* _tmp50_ = NULL; DbusmenuMenuitem* _tmp53_; DbusmenuMenuitem* _tmp54_; _tmp47_ = self->root_item; _tmp48_ = dbusmenu_menuitem_property_get (_tmp47_, DBUSMENU_PLAYLIST_MENUITEM_PATH); _tmp49_ = item; _tmp50_ = dbusmenu_menuitem_property_get (_tmp49_, DBUSMENU_PLAYLIST_MENUITEM_PATH); if (g_strcmp0 (_tmp48_, _tmp50_) == 0) { DbusmenuMenuitem* _tmp51_; const gchar* _tmp52_ = NULL; _tmp51_ = self->root_item; _tmp52_ = _ ("Choose Playlist"); dbusmenu_menuitem_property_set (_tmp51_, DBUSMENU_MENUITEM_PROP_LABEL, _tmp52_); } _tmp53_ = self->root_item; _tmp54_ = item; dbusmenu_menuitem_child_delete (_tmp53_, _tmp54_); } _g_object_unref0 (item); } _g_object_unref0 (_item_it); } }
WndInfo *registerWindow(guint32 windowXid, jeventcallback handler) { // _info("register new window"); WndInfo *wi = (WndInfo *) malloc(sizeof(WndInfo)); memset(wi, 0, sizeof(WndInfo)); wi->xid = (guint32) windowXid; wi->menuPath = malloc(64); sprintf(wi->menuPath, "/com/canonical/menu/0x%x", windowXid); wi->menuroot = dbusmenu_menuitem_new(); if (wi->menuroot == NULL) { _error("can't create menuitem for new root"); _releaseWindow(wi); return NULL; } g_object_set_data(G_OBJECT(wi->menuroot), MENUITEM_JHANDLER_PROPERTY, handler); dbusmenu_menuitem_property_set(wi->menuroot, DBUSMENU_MENUITEM_PROP_LABEL, "DBusMenuRoot"); wi->server = dbusmenu_server_new(wi->menuPath); dbusmenu_server_set_root(wi->server, wi->menuroot); wi->registrar = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, NULL, DBUS_NAME, REG_OBJECT, REG_IFACE, NULL, NULL); if (wi->registrar == NULL) { // probably need to watch for registrar on dbus // guint watcher = g_bus_watch_name(G_BUS_TYPE_SESSION, DBUS_NAME, G_BUS_NAME_WATCHER_FLAGS_NONE, on_registrar_available, on_registrar_unavailable); _error("can't obtain registrar"); _releaseWindow(wi); return NULL; } char buf[1024]; _printWndInfo(wi, buf, 1024); _logmsg(LOG_LEVEL_INFO, "new window info: %s", buf); GError *error = NULL; g_dbus_proxy_call_sync( wi->registrar, "RegisterWindow", g_variant_new("(uo)", windowXid, wi->menuPath), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error != NULL) { _logmsg(LOG_LEVEL_ERROR, "Unable to register window, error: %s", error->message); g_error_free(error); _releaseWindow(wi); return NULL; } wi->jhandler = handler; g_signal_connect(wi->registrar, "notify::g-name-owner", G_CALLBACK(_onDbusOwnerChange), wi); return wi; }