/**
* Add menu items to the "Recent files" submenu.
*/
gboolean affiche_derniers_fichiers_ouverts ( void )
{
gint i;
GtkActionGroup * action_group;
efface_derniers_fichiers_ouverts ();
if ( conf.nb_derniers_fichiers_ouverts > conf.nb_max_derniers_fichiers_ouverts )
{
conf.nb_derniers_fichiers_ouverts = conf.nb_max_derniers_fichiers_ouverts;
}
if ( ! conf.nb_derniers_fichiers_ouverts || ! conf.nb_max_derniers_fichiers_ouverts )
{
return FALSE;
}
action_group = gtk_action_group_new ( "Group2" );
for ( i = 0 ; i < conf.nb_derniers_fichiers_ouverts ; i++ )
{
gchar *tmp_name;
GtkAction *action;
tmp_name = g_strdup_printf ( "LastFile%d", i );
action = gtk_action_new ( tmp_name,
tab_noms_derniers_fichiers_ouverts[i],
"",
"" );
g_free ( tmp_name );
g_signal_connect ( action,
"activate",
G_CALLBACK ( gsb_file_open_direct_menu ),
GINT_TO_POINTER ( i ) );
gtk_action_group_add_action ( action_group, action );
}
gtk_ui_manager_insert_action_group ( ui_manager, action_group, 1 );
recent_files_merge_id = gtk_ui_manager_new_merge_id ( ui_manager );
for ( i=0 ; i < conf.nb_derniers_fichiers_ouverts ; i++ )
{
gchar *tmp_name;
gchar *tmp_label;
tmp_name = g_strdup_printf ( "LastFile%d", i );
tmp_label = g_strdup_printf ( "_%d LastFile%d", i, i );
gtk_ui_manager_add_ui ( ui_manager,
recent_files_merge_id,
"/menubar/FileMenu/RecentFiles/",
tmp_label,
tmp_name,
GTK_UI_MANAGER_MENUITEM,
FALSE );
g_free ( tmp_name );
g_free ( tmp_label );
}
/* add a separator */
gtk_ui_manager_add_ui ( ui_manager,
merge_id,
"/menubar/FileMenu/Open/",
NULL,
NULL,
GTK_UI_MANAGER_SEPARATOR,
FALSE );
gtk_ui_manager_ensure_update ( ui_manager );
#ifdef GTKOSXAPPLICATION
grisbi_osx_app_update_menus_cb ( );
#endif /* GTKOSXAPPLICATION */
return FALSE;
}
void
plug_in_menus_setup (GimpUIManager *manager,
const gchar *ui_path)
{
GimpPlugInManager *plug_in_manager;
GTree *menu_entries;
GSList *list;
guint merge_id;
gint i;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
plug_in_manager = manager->gimp->plug_in_manager;
merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
for (i = 0; i < manager->gimp->config->plug_in_history_size; i++)
{
gchar *action_name;
gchar *action_path;
action_name = g_strdup_printf ("plug-in-recent-%02d", i + 1);
action_path = g_strdup_printf ("%s/Filters/Recently Used/Plug-Ins",
ui_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (action_name);
g_free (action_path);
}
menu_entries = g_tree_new_full ((GCompareDataFunc) strcmp, NULL,
g_free,
(GDestroyNotify) plug_in_menu_entry_free);
for (list = plug_in_manager->plug_in_procedures;
list;
list = g_slist_next (list))
{
GimpPlugInProcedure *plug_in_proc = list->data;
if (! plug_in_proc->prog)
continue;
g_signal_connect_object (plug_in_proc, "menu-path-added",
G_CALLBACK (plug_in_menus_menu_path_added),
manager, 0);
if (plug_in_proc->menu_paths &&
! plug_in_proc->file_proc)
{
GList *path;
for (path = plug_in_proc->menu_paths; path; path = g_list_next (path))
{
if (g_str_has_prefix (path->data, manager->name))
{
PlugInMenuEntry *entry = g_slice_new0 (PlugInMenuEntry);
const gchar *progname;
const gchar *locale_domain;
entry->proc = plug_in_proc;
entry->menu_path = path->data;
progname = gimp_plug_in_procedure_get_progname (plug_in_proc);
locale_domain =
gimp_plug_in_manager_get_locale_domain (plug_in_manager,
progname, NULL);
if (plug_in_proc->menu_label)
{
gchar *menu;
menu = g_strconcat (dgettext (locale_domain,
path->data),
"/",
dgettext (locale_domain,
plug_in_proc->menu_label),
NULL);
plug_in_menus_tree_insert (menu_entries, menu, entry);
g_free (menu);
}
else
{
plug_in_menus_tree_insert (menu_entries,
dgettext (locale_domain,
path->data),
entry);
}
}
}
}
}
g_object_set_data (G_OBJECT (manager), "ui-path", (gpointer) ui_path);
g_tree_foreach (menu_entries,
(GTraverseFunc) plug_in_menus_tree_traverse,
manager);
g_object_set_data (G_OBJECT (manager), "ui-path", NULL);
g_tree_destroy (menu_entries);
g_signal_connect_object (manager->gimp->pdb, "register-procedure",
G_CALLBACK (plug_in_menus_register_procedure),
manager, 0);
g_signal_connect_object (manager->gimp->pdb, "unregister-procedure",
G_CALLBACK (plug_in_menus_unregister_procedure),
manager, 0);
}
static void
window_menu_display_opened (GdkDisplayManager *disp_manager,
GdkDisplay *display,
GimpUIManager *manager)
{
GtkUIManager *ui_manager = GTK_UI_MANAGER (manager);
const gchar *group_name;
const gchar *ui_path;
const gchar *display_name;
gchar *action_path;
gchar *merge_key;
guint merge_id;
gint n_screens;
gint i;
group_name = g_object_get_data (G_OBJECT (manager),
"move-to-screen-group-name");
ui_path = g_object_get_data (G_OBJECT (manager),
"move-to-screen-ui-path");
action_path = g_strdup_printf ("%s/Move to Screen", ui_path);
display_name = gdk_display_get_name (display);
if (! display_name)
display_name = "eek";
merge_key = g_strdup_printf ("%s-display-merge-id", display_name);
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
g_object_set_data (G_OBJECT (manager), merge_key,
GUINT_TO_POINTER (merge_id));
g_free (merge_key);
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen;
gchar *screen_name;
gchar *action_name;
screen = gdk_display_get_screen (display, i);
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
gtk_ui_manager_add_ui (ui_manager, merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (action_name);
}
g_free (action_path);
g_signal_connect_object (display, "closed",
G_CALLBACK (window_menu_display_closed),
G_OBJECT (manager), 0);
}
static void
plug_in_menus_add_proc (GimpUIManager *manager,
const gchar *ui_path,
GimpPlugInProcedure *proc,
const gchar *menu_path)
{
gchar *path;
gchar *merge_key;
gchar *stripped_path;
gchar *action_path;
guint merge_id;
guint menu_merge_id;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
path = g_strdup (menu_path);
if (! proc->menu_label)
{
gchar *p;
if (! path)
return;
p = strrchr (path, '/');
if (! p)
{
g_free (path);
return;
}
*p = '\0';
}
merge_key = g_strdup_printf ("%s-merge-id", gimp_object_get_name (proc));
merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
merge_key));
if (! merge_id)
{
merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
g_object_set_data (G_OBJECT (manager), merge_key,
GUINT_TO_POINTER (merge_id));
}
g_free (merge_key);
menu_merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager),
"plug-in-menu-merge-id"));
if (! menu_merge_id)
{
menu_merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager));
g_object_set_data (G_OBJECT (manager), "plug-in-menu-merge-id",
GUINT_TO_POINTER (menu_merge_id));
}
stripped_path = gimp_strip_uline (path);
action_path = plug_in_menus_build_path (manager, ui_path, menu_merge_id,
stripped_path, FALSE);
g_free (stripped_path);
if (! action_path)
{
g_free (path);
return;
}
GIMP_LOG (MENUS, "adding menu item for '%s' (@ %s)",
gimp_object_get_name (proc), action_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path,
gimp_object_get_name (proc),
gimp_object_get_name (proc),
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (action_path);
g_free (path);
}
static gchar *
plug_in_menus_build_path (GimpUIManager *manager,
const gchar *ui_path,
guint merge_id,
const gchar *menu_path,
gboolean for_menu)
{
gchar *action_path;
if (! strchr (menu_path, '/'))
{
action_path = g_strdup (ui_path);
goto make_placeholder;
}
action_path = g_strdup_printf ("%s%s", ui_path, strchr (menu_path, '/'));
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), action_path))
{
gchar *parent_menu_path = g_strdup (menu_path);
gchar *parent_action_path = NULL;
gchar *menu_item_name;
menu_item_name = strrchr (parent_menu_path, '/');
*menu_item_name++ = '\0';
if (menu_item_name)
parent_action_path = plug_in_menus_build_path (manager,
ui_path, merge_id,
parent_menu_path, TRUE);
if (parent_action_path)
{
g_free (action_path);
action_path = g_strdup_printf ("%s/%s",
parent_action_path, menu_item_name);
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
action_path))
{
GIMP_LOG (MENUS, "adding menu '%s' at path '%s' for action '%s'",
menu_item_name, action_path, menu_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
parent_action_path, menu_item_name,
menu_path,
GTK_UI_MANAGER_MENU,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Menus", NULL,
GTK_UI_MANAGER_PLACEHOLDER,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Separator", NULL,
GTK_UI_MANAGER_SEPARATOR,
FALSE);
}
g_free (parent_action_path);
}
else
{
g_free (action_path);
action_path = NULL;
}
g_free (parent_menu_path);
}
make_placeholder:
if (action_path && for_menu)
{
gchar *placeholder_path = g_strdup_printf ("%s/%s", action_path, "Menus");
if (gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
placeholder_path))
{
g_free (action_path);
return placeholder_path;
}
g_free (placeholder_path);
}
return action_path;
}
static void
add_extension_menu_items (CajaWindow *window,
guint merge_id,
GtkActionGroup *action_group,
GList *menu_items,
const char *subdirectory)
{
GtkUIManager *ui_manager;
GList *l;
ui_manager = window->details->ui_manager;
for (l = menu_items; l; l = l->next)
{
CajaMenuItem *item;
CajaMenu *menu;
GtkAction *action;
char *path;
item = CAJA_MENU_ITEM (l->data);
g_object_get (item, "menu", &menu, NULL);
action = caja_action_from_menu_item (item);
gtk_action_group_add_action_with_accel (action_group, action, NULL);
path = g_build_path ("/", POPUP_PATH_EXTENSION_ACTIONS, subdirectory, NULL);
gtk_ui_manager_add_ui (ui_manager,
merge_id,
path,
gtk_action_get_name (action),
gtk_action_get_name (action),
(menu != NULL) ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (path);
path = g_build_path ("/", MENU_PATH_EXTENSION_ACTIONS, subdirectory, NULL);
gtk_ui_manager_add_ui (ui_manager,
merge_id,
path,
gtk_action_get_name (action),
gtk_action_get_name (action),
(menu != NULL) ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (path);
/* recursively fill the menu */
if (menu != NULL)
{
char *subdir;
GList *children;
children = caja_menu_get_items (menu);
subdir = g_build_path ("/", subdirectory, "/", gtk_action_get_name (action), NULL);
add_extension_menu_items (window,
merge_id,
action_group,
children,
subdir);
caja_menu_item_list_free (children);
g_free (subdir);
}
}
}
void
caja_menus_append_bookmark_to_menu (CajaWindow *window,
CajaBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
CajaBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
char *name;
char *path;
GdkPixbuf *pixbuf;
GtkAction *action;
GtkWidget *menuitem;
g_assert (CAJA_IS_WINDOW (window));
g_assert (CAJA_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = caja_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
pixbuf = caja_bookmark_get_pixbuf (bookmark, GTK_ICON_SIZE_MENU);
g_snprintf (action_name, sizeof (action_name), "%s%d", parent_id, index_in_parent);
action = gtk_action_new (action_name,
name,
_("Go to the location specified by this bookmark"),
NULL);
g_object_set_data_full (G_OBJECT (action), "menu-icon",
g_object_ref (pixbuf),
g_object_unref);
g_signal_connect_data (action, "activate",
G_CALLBACK (activate_bookmark_in_menu_item),
bookmark_holder,
bookmark_holder_free_cover, 0);
gtk_action_group_add_action (action_group,
GTK_ACTION (action));
g_object_unref (action);
gtk_ui_manager_add_ui (window->details->ui_manager,
merge_id,
parent_path,
action_name,
action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
path = g_strdup_printf ("%s/%s", parent_path, action_name);
menuitem = gtk_ui_manager_get_widget (window->details->ui_manager,
path);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
g_object_unref (pixbuf);
g_free (path);
g_free (name);
}
/**
* nautilus_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NautilusWindow.
*/
void
nautilus_window_initialize_menus (NautilusWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
window->details->ui_manager = gtk_ui_manager_new ();
ui_manager = window->details->ui_manager;
/* shell actions */
action_group = gtk_action_group_new ("ShellActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
window->details->main_action_group = action_group;
gtk_action_group_add_actions (action_group,
main_entries, G_N_ELEMENTS (main_entries),
window);
gtk_action_group_add_toggle_actions (action_group,
main_toggle_entries, G_N_ELEMENTS (main_toggle_entries),
window);
gtk_action_group_add_radio_actions (action_group,
view_radio_entries, G_N_ELEMENTS (view_radio_entries),
-1, G_CALLBACK (action_view_radio_changed),
window);
action = nautilus_option_menu_action_new ("Zoom Options",
_("Zoom"), _("Zoom Options"), NULL);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
nautilus_window_menus_set_visibility_for_app_menu (window);
window->details->app_menu_visibility_id =
g_signal_connect_swapped (gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window))),
"notify::gtk-shell-shows-app-menu",
G_CALLBACK (nautilus_window_menus_set_visibility_for_app_menu), window);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
/* Alt+N for the first 10 tabs */
for (i = 0; i < 10; ++i) {
gchar action_name[80];
gchar accelerator[80];
snprintf(action_name, sizeof (action_name), "Tab%d", i);
action = gtk_action_new (action_name, NULL, NULL, NULL);
g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i));
g_signal_connect (action, "activate",
G_CALLBACK (action_tab_change_action_activate_callback), window);
snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10);
gtk_action_group_add_action_with_accel (action_group, action, accelerator);
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
gtk_ui_manager_new_merge_id (ui_manager),
"/",
action_name,
action_name,
GTK_UI_MANAGER_ACCELERATOR,
FALSE);
}
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
g_object_unref (action_group); /* owned by ui_manager */
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
g_signal_connect (ui_manager, "connect-proxy",
G_CALLBACK (connect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/gnome/nautilus/nautilus-shell-ui.xml", NULL);
/* set actions for option menu items */
populate_option_menu_items (window);
}
static void
set_up_tree_view (TotemYouTubePlugin *self, GtkBuilder *builder, guint key)
{
GtkUIManager *ui_manager;
GtkActionGroup *action_group;
GtkAction *action, *menu_item;
GtkWidget *vscroll, *tree_view;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* Add the cell renderer. This can't be done with GtkBuilder, because it unavoidably sets the expand parameter to FALSE */
/* TODO: Depends on bug #453692 */
renderer = GTK_CELL_RENDERER (totem_cell_renderer_video_new (TRUE));
column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder,
(key == SEARCH_TREE_VIEW) ? "yt_treeview_search_column" : "yt_treeview_related_column"));
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "thumbnail", 0, "title", 1, NULL);
/* Give the video lists a handle to Totem and connect their scrollbar signals */
if (key == SEARCH_TREE_VIEW) {
tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_search"));
vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_search")));
self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_search"));
self->tree_view[key] = GTK_TREE_VIEW (tree_view);
self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_search"));
} else {
tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_related"));
vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_related")));
self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_related"));
self->tree_view[key] = GTK_TREE_VIEW (tree_view);
self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_related"));
}
g_object_set (tree_view, "totem", self->totem, NULL);
g_signal_connect (vscroll, "button-press-event", G_CALLBACK (button_press_event_cb), self);
g_signal_connect (vscroll, "button-release-event", G_CALLBACK (button_release_event_cb), self);
/* Add the extra popup menu options. This is done here rather than in the UI file, because it's done for multiple treeviews;
* if it were done in the UI file, the same action group would be used multiple times, which GTK+ doesn't like. */
ui_manager = totem_video_list_get_ui_manager (TOTEM_VIDEO_LIST (tree_view));
action_group = gtk_action_group_new ("youtube-action-group");
action = gtk_action_new ("open-in-web-browser", _("_Open in Web Browser"), _("Open the video in your web browser"), "gtk-jump-to");
gtk_action_group_add_action_with_accel (action_group, action, NULL);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 1);
gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager),
"/ui/totem-video-list-popup/",
"open-in-web-browser",
"open-in-web-browser",
GTK_UI_MANAGER_MENUITEM,
FALSE);
menu_item = gtk_ui_manager_get_action (ui_manager, "/ui/totem-video-list-popup/open-in-web-browser");
g_signal_connect (menu_item, "activate", G_CALLBACK (open_in_web_browser_activate_cb), self);
/* Connect to more scroll events */
#if GTK_CHECK_VERSION(3, 0, 0)
self->vadjust[key] = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view));
#else
self->vadjust[key] = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(tree_view));
#endif
g_signal_connect (self->vadjust[key], "value-changed", G_CALLBACK (value_changed_cb), self);
self->cancel_button = GTK_WIDGET (gtk_builder_get_object (builder, "yt_cancel_button"));
}
static void
anjuta_docman_update_documents_menu (AnjutaDocman* docman)
{
AnjutaDocmanPriv *priv = docman->priv;
GtkUIManager* ui = GTK_UI_MANAGER (anjuta_shell_get_ui (ANJUTA_PLUGIN (priv->plugin)->shell,
NULL));
GList *actions, *l;
gint n, i;
guint id;
GSList *group = NULL;
g_return_if_fail (priv->documents_action_group != NULL);
if (priv->documents_merge_id != 0)
gtk_ui_manager_remove_ui (ui,
priv->documents_merge_id);
actions = gtk_action_group_list_actions (priv->documents_action_group);
for (l = actions; l != NULL; l = l->next)
{
g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data),
G_CALLBACK (on_document_toggled),
docman);
gtk_action_group_remove_action (priv->documents_action_group,
GTK_ACTION (l->data));
}
g_list_free (actions);
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (docman));
id = (n > 0) ? gtk_ui_manager_new_merge_id (ui) : 0;
for (i = 0; i < n; i++)
{
AnjutaDocmanPage* page;
GtkRadioAction *action;
gchar *action_name;
const gchar *tab_name;
gchar *accel;
page = anjuta_docman_get_nth_page (docman, i);
/* NOTE: the action is associated to the position of the tab in
* the notebook not to the tab itself! This is needed to work
* around the gtk+ bug #170727: gtk leaves around the accels
* of the action. Since the accel depends on the tab position
* the problem is worked around, action with the same name always
* get the same accel.
*/
action_name = g_strdup_printf ("Tab_%d", i);
tab_name = gtk_label_get_label (GTK_LABEL (page->label));
/* alt + 1, 2, 3... 0 to switch to the first ten tabs */
accel = (i < 10) ? g_strdup_printf ("<alt>%d", (i + 1) % 10) : NULL;
action = gtk_radio_action_new (action_name,
tab_name,
NULL,
NULL,
i);
if (group != NULL)
gtk_radio_action_set_group (action, group);
/* note that group changes each time we add an action, so it must be updated */
group = gtk_radio_action_get_group (action);
gtk_action_group_add_action_with_accel (priv->documents_action_group,
GTK_ACTION (action),
accel);
g_signal_connect (action,
"toggled",
G_CALLBACK (on_document_toggled),
docman);
gtk_ui_manager_add_ui (ui,
id,
MENU_PLACEHOLDER,
action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
if (i == gtk_notebook_get_current_page (GTK_NOTEBOOK (docman)))
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
g_object_unref (action);
g_free (action_name);
g_free (accel);
}
anjuta_docman_update_documents_menu_status (docman);
priv->documents_merge_id = id;
}
/**
* nemo_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NemoWindow.
*/
void
nemo_window_initialize_menus (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
if (window->details->ui_manager == NULL){
window->details->ui_manager = gtk_ui_manager_new ();
}
ui_manager = window->details->ui_manager;
/* shell actions */
action_group = gtk_action_group_new ("ShellActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
window->details->main_action_group = action_group;
gtk_action_group_add_actions (action_group,
main_entries, G_N_ELEMENTS (main_entries),
window);
gtk_action_group_add_toggle_actions (action_group,
main_toggle_entries, G_N_ELEMENTS (main_toggle_entries),
window);
gtk_action_group_add_radio_actions (action_group,
main_radio_entries, G_N_ELEMENTS (main_radio_entries),
0, G_CALLBACK (sidebar_radio_entry_changed_cb),
window);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_EDIT_LOCATION);
g_object_set (action, "short_label", _("_Location"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_SHOW_HIDDEN_FILES);
g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_HIDDEN_FILES,
G_CALLBACK(show_hidden_files_preference_callback),
window);
/* Alt+N for the first 10 tabs */
for (i = 0; i < 10; ++i) {
gchar action_name[80];
gchar accelerator[80];
snprintf(action_name, sizeof (action_name), "Tab%d", i);
action = gtk_action_new (action_name, NULL, NULL, NULL);
g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i));
g_signal_connect (action, "activate",
G_CALLBACK (action_tab_change_action_activate_callback), window);
snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10);
gtk_action_group_add_action_with_accel (action_group, action, accelerator);
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
gtk_ui_manager_new_merge_id (ui_manager),
"/",
action_name,
action_name,
GTK_UI_MANAGER_ACCELERATOR,
FALSE);
}
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
g_object_unref (action_group); /* owned by ui_manager */
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
g_signal_connect (ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), window);
g_signal_connect (ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/nemo/nemo-shell-ui.xml", NULL);
nemo_window_initialize_trash_icon_monitor (window);
nemo_window_initialize_go_menu (window);
}
static void
pluma_spell_plugin_activate (PeasActivatable *activatable)
{
PlumaSpellPlugin *plugin;
PlumaSpellPluginPrivate *data;
PlumaWindow *window;
GtkUIManager *manager;
GList *docs, *l;
pluma_debug (DEBUG_PLUGINS);
plugin = PLUMA_SPELL_PLUGIN (activatable);
data = plugin->priv;
window = PLUMA_WINDOW (data->window);
manager = pluma_window_get_ui_manager (window);
data->action_group = gtk_action_group_new ("PlumaSpellPluginActions");
gtk_action_group_set_translation_domain (data->action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (data->action_group,
action_entries,
G_N_ELEMENTS (action_entries),
plugin);
gtk_action_group_add_toggle_actions (data->action_group,
toggle_action_entries,
G_N_ELEMENTS (toggle_action_entries),
plugin);
gtk_ui_manager_insert_action_group (manager, data->action_group, -1);
data->ui_id = gtk_ui_manager_new_merge_id (manager);
data->message_cid = gtk_statusbar_get_context_id
(GTK_STATUSBAR (pluma_window_get_statusbar (window)),
"spell_plugin_message");
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"CheckSpell",
"CheckSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"AutoSpell",
"AutoSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"ConfigSpell",
"ConfigSpell",
GTK_UI_MANAGER_MENUITEM,
FALSE);
update_ui (plugin);
docs = pluma_window_get_documents (window);
for (l = docs; l != NULL; l = g_list_next (l))
{
PlumaDocument *doc = PLUMA_DOCUMENT (l->data);
set_auto_spell_from_metadata (plugin, doc,
data->action_group);
g_signal_handlers_disconnect_by_func (doc,
on_document_loaded,
plugin);
g_signal_handlers_disconnect_by_func (doc,
on_document_saved,
plugin);
}
data->tab_added_id =
g_signal_connect (window, "tab-added",
G_CALLBACK (tab_added_cb), plugin);
data->tab_removed_id =
g_signal_connect (window, "tab-removed",
G_CALLBACK (tab_removed_cb), plugin);
}
static gboolean
impl_activate (IdolPlugin *plugin, IdolObject *idol, GError **error)
{
IdolDiscRecorderPlugin *pi = IDOL_DISC_RECORDER_PLUGIN (plugin);
GtkUIManager *uimanager = NULL;
GtkAction *action;
char *path;
/* make sure brasero is in the path */
path = g_find_program_in_path ("brasero");
if (!path)
return FALSE;
g_free (path);
//FIXME this shouldn't be necessary
#if 0
/* Set up to use brasero icons */
path = g_build_path (G_DIR_SEPARATOR_S, LIBBRASERO_MEDIA_INSTALL, "/share/brasero/icons", NULL);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), path);
g_free (path);
#endif
pi->idol = idol;
g_signal_connect (idol,
"file-opened",
G_CALLBACK (idol_disc_recorder_file_opened),
plugin);
g_signal_connect (idol,
"file-closed",
G_CALLBACK (idol_disc_recorder_file_closed),
plugin);
/* add UI */
pi->action_group = gtk_action_group_new ("DiscRecorderActions");
gtk_action_group_set_translation_domain (pi->action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (pi->action_group,
idol_disc_recorder_plugin_actions,
G_N_ELEMENTS (idol_disc_recorder_plugin_actions),
pi);
uimanager = idol_get_ui_manager (idol);
gtk_ui_manager_insert_action_group (uimanager, pi->action_group, -1);
g_object_unref (pi->action_group);
pi->ui_merge_id = gtk_ui_manager_new_merge_id (uimanager);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/tmw-menubar/movie/burn-placeholder",
"VideoBurnToDisc",
"VideoBurnToDisc",
GTK_UI_MANAGER_MENUITEM,
TRUE);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/idol-main-popup/burn-placeholder",
"VideoBurnToDisc",
"VideoBurnToDisc",
GTK_UI_MANAGER_MENUITEM,
TRUE);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/tmw-menubar/movie/burn-placeholder",
"VideoDVDCopy",
"VideoDVDCopy",
GTK_UI_MANAGER_MENUITEM,
TRUE);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/idol-main-popup/burn-placeholder",
"VideoDVDCopy",
"VideoDVDCopy",
GTK_UI_MANAGER_MENUITEM,
TRUE);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/tmw-menubar/movie/burn-placeholder",
"VideoVCDCopy",
"VideoVCDCopy",
GTK_UI_MANAGER_MENUITEM,
TRUE);
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
"/ui/idol-main-popup/burn-placeholder",
"VideoVCDCopy",
"VideoVCDCopy",
GTK_UI_MANAGER_MENUITEM,
TRUE);
if (!idol_is_paused (idol) && !idol_is_playing (idol)) {
action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
gtk_action_set_visible (action, FALSE); }
else {
char *mrl;
mrl = idol_get_current_mrl (idol);
idol_disc_recorder_file_opened (idol, mrl, pi);
g_free (mrl);
}
return TRUE;
}
static void
impl_activate (RBPlugin *plugin,
RBShell *shell)
{
RBDiscRecorderPlugin *pi = RB_DISC_RECORDER_PLUGIN (plugin);
GtkUIManager *uimanager = NULL;
GtkAction *action;
int i;
pi->enabled = TRUE;
rb_debug ("RBDiscRecorderPlugin activating");
brasero_media_library_start ();
pi->shell = shell;
g_object_get (shell,
"ui-manager", &uimanager,
NULL);
g_signal_connect_object (G_OBJECT (shell),
"notify::selected-source",
G_CALLBACK (shell_selected_source_notify_cb),
pi, 0);
/* add UI */
pi->action_group = gtk_action_group_new ("DiscRecorderActions");
gtk_action_group_set_translation_domain (pi->action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (pi->action_group,
rb_disc_recorder_plugin_actions, G_N_ELEMENTS (rb_disc_recorder_plugin_actions),
pi);
gtk_ui_manager_insert_action_group (uimanager, pi->action_group, 0);
pi->ui_merge_id = gtk_ui_manager_new_merge_id (uimanager);
for (i = 0; i < G_N_ELEMENTS (ui_paths); i++) {
if (ui_paths[i].for_burn)
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
ui_paths[i].path,
"MusicPlaylistBurnToDiscPlaylistMenu",
"MusicPlaylistBurnToDiscPlaylist",
GTK_UI_MANAGER_AUTO,
FALSE);
if (ui_paths[i].for_copy)
gtk_ui_manager_add_ui (uimanager,
pi->ui_merge_id,
ui_paths[i].path,
"MusicAudioCDDuplicateMenu",
"MusicAudioCDDuplicate",
GTK_UI_MANAGER_AUTO,
FALSE);
}
g_object_unref (uimanager);
action = gtk_action_group_get_action (pi->action_group, "MusicPlaylistBurnToDiscPlaylist");
/* Translators: this is the toolbar button label for */
/* Create Audio CD action */
g_object_set (action, "short-label", _("Burn"), NULL);
action = gtk_action_group_get_action (pi->action_group,
"MusicAudioCDDuplicate");
/* Translators: this is the toolbar button label for */
/* Duplicate Audio CD action */
g_object_set (action, "short-label", _("Copy CD"), NULL);
update_source (pi, shell);
}
static void rc_plugin_tag_ui_init()
{
GtkWidget *path_label, *title_label, *artist_label, *album_label;
GtkWidget *genre_label, *comment_label, *track_label, *year_label;
GtkWidget *format_label, *channel_label, *bd_label, *sr_label;
GtkWidget *bitrate_label, *length_label, *rg_label;
GtkWidget *tag_frame, *media_frame;
GtkWidget *tag_table, *media_table;
GtkWidget *info_vbox, *media_vbox, *path_hbox, *art_hbox;
GtkWidget *button_hbox;
GtkWidget *info_scr_window;
GtkActionEntry menu_action_entry, popup_action_entry;
path_label = gtk_label_new(_("Path"));
title_label = gtk_label_new(_("Title"));
artist_label = gtk_label_new(_("Artist"));
album_label = gtk_label_new(_("Album"));
genre_label = gtk_label_new(_("Genre"));
comment_label = gtk_label_new(_("Comment"));
track_label = gtk_label_new(_("Track"));
year_label = gtk_label_new(_("Year"));
format_label = gtk_label_new(_("Format"));
channel_label = gtk_label_new(_("Channel"));
bd_label = gtk_label_new(_("Bit Depth"));
sr_label = gtk_label_new(_("Sample Rate"));
bitrate_label = gtk_label_new(_("Bitrate"));
length_label = gtk_label_new(_("Length"));
rg_label = gtk_label_new(_("Replay Gain"));
tag_frame = gtk_frame_new(_("Tag"));
media_frame = gtk_frame_new(_("Media Information"));
tag_table = gtk_table_new(5, 4, FALSE);
media_table = gtk_table_new(7, 2, FALSE);
info_vbox = gtk_vbox_new(FALSE, 1);
media_vbox = gtk_vbox_new(FALSE, 1);
path_hbox = gtk_hbox_new(FALSE, 4);
art_hbox = gtk_hbox_new(FALSE, 4);
button_hbox = gtk_hbutton_box_new();
info_scr_window = gtk_scrolled_window_new(NULL, NULL);
tag_ui.tag_main_vbox = gtk_vbox_new(FALSE, 0);
tag_ui.path_entry = gtk_entry_new();
tag_ui.title_entry = gtk_entry_new();
tag_ui.artist_entry = gtk_entry_new();
tag_ui.album_entry = gtk_entry_new();
tag_ui.genre_entry = gtk_entry_new();
tag_ui.comment_entry = gtk_entry_new();
tag_ui.track_entry = gtk_entry_new();
tag_ui.year_entry = gtk_entry_new();
tag_ui.format_entry = gtk_label_new(NULL);
tag_ui.channel_entry = gtk_label_new(NULL);
tag_ui.bd_entry = gtk_label_new(NULL);
tag_ui.sr_entry = gtk_label_new(NULL);
tag_ui.bitrate_entry = gtk_label_new(NULL);
tag_ui.length_entry = gtk_label_new(NULL);
tag_ui.rg_entry = gtk_entry_new();
tag_ui.reload_button = gtk_button_new_with_mnemonic(_("Re_load"));
tag_ui.save_button = gtk_button_new_with_mnemonic(_("_Save"));
gtk_editable_set_editable(GTK_EDITABLE(tag_ui.path_entry), FALSE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(info_scr_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(tag_table), title_label, 0, 1, 0, 1,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.title_entry, 1, 4, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), artist_label, 0, 1, 1, 2,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.artist_entry, 1, 4, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), album_label, 0, 1, 2, 3,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.album_entry, 1, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), track_label, 2, 3, 2, 3,
0, GTK_FILL, 4, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.track_entry, 3, 4, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), genre_label, 0, 1, 3, 4,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.genre_entry, 1, 2, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), year_label, 2, 3, 3, 4,
0, GTK_FILL, 4, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.year_entry, 3, 4, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), comment_label, 0, 1, 4, 5,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tag_table), tag_ui.comment_entry, 1, 4, 4, 5,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), format_label, 0, 1, 0, 1,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.format_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), channel_label, 0, 1, 1, 2,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.channel_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), bd_label, 0, 1, 2, 3,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.bd_entry, 1, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), sr_label, 0, 1, 3, 4,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.sr_entry, 1, 2, 3, 4,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), bitrate_label, 0, 1, 4, 5,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.bitrate_entry, 1, 2, 4, 5,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), length_label, 0, 1, 5, 6,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.length_entry, 1, 2, 5, 6,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), rg_label, 0, 1, 6, 7,
0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(media_table), tag_ui.rg_entry, 1, 2, 6, 7,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_container_add(GTK_CONTAINER(tag_frame), tag_table);
gtk_container_add(GTK_CONTAINER(media_frame), media_table);
gtk_box_pack_start(GTK_BOX(media_vbox), tag_frame, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(media_vbox), media_frame, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(path_hbox), path_label, FALSE, FALSE, 4);
gtk_box_pack_start(GTK_BOX(path_hbox), tag_ui.path_entry, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(info_vbox), path_hbox, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(info_vbox), media_vbox, FALSE, FALSE, 1);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(info_scr_window),
info_vbox);
gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.reload_button, FALSE,
FALSE, 4);
gtk_box_pack_start(GTK_BOX(button_hbox), tag_ui.save_button, FALSE,
FALSE, 4);
gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), info_scr_window,
TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(tag_ui.tag_main_vbox), button_hbox,
FALSE, FALSE, 8);
g_signal_connect(G_OBJECT(tag_ui.track_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.year_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.rg_entry), "insert-text",
G_CALLBACK(rc_plugin_tag_rg_entry_insert_text_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.reload_button), "clicked",
G_CALLBACK(rc_plugin_tag_reload_data_cb), NULL);
g_signal_connect(G_OBJECT(tag_ui.save_button), "clicked",
G_CALLBACK(rc_plugin_tag_data_save_cb), NULL);
menu_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager());
menu_action_entry.name = "EditTagEditor";
menu_action_entry.label = _("Tag Editor");
menu_action_entry.accelerator = NULL;
menu_action_entry.stock_id = NULL;
menu_action_entry.tooltip = _("Edit the tag of the selected music");
menu_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb);
gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), menu_id,
"/RCMenuBar/EditMenu/EditSep2", "EditTagEditor", "EditTagEditor",
GTK_UI_MANAGER_MENUITEM, TRUE);
gtk_action_group_add_actions(rc_gui_get_action_group(),
&menu_action_entry, 1, NULL);
popup_id = gtk_ui_manager_new_merge_id(rc_gui_get_ui_manager());
popup_action_entry.name = "List2TagEditor";
popup_action_entry.label = _("Tag Editor");
popup_action_entry.accelerator = NULL;
popup_action_entry.stock_id = NULL;
popup_action_entry.tooltip = _("Edit the tag of the selected music");
popup_action_entry.callback = G_CALLBACK(rc_plugin_tag_edit_menu_cb);
gtk_ui_manager_add_ui(rc_gui_get_ui_manager(), popup_id,
"/List2PopupMenu/List2Sep2", "List2TagEditor", "List2TagEditor",
GTK_UI_MANAGER_MENUITEM, FALSE);
gtk_action_group_add_actions(rc_gui_get_action_group(),
&popup_action_entry, 1, NULL);
}
static void
update_device_list (GtkTreeIter *parent)
{
GtkUIManager *uimanager;
GtkTreeIter iter;
gboolean cont;
guint num_devices;
GList *actions, *l;
num_devices = 0;
uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager"));
if (parent == NULL) {
/* No default adapter? Remove everything */
actions = gtk_action_group_list_actions (devices_action_group);
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
goto done;
}
/* Get a list of actions, and we'll remove the ones with a
* device in the list. We remove the submenu items first */
actions = gtk_action_group_list_actions (devices_action_group);
for (l = actions; l != NULL; l = l->next) {
if (bluetooth_verify_address (gtk_action_get_name (l->data)) == FALSE)
l->data = NULL;
}
actions = g_list_remove_all (actions, NULL);
cont = gtk_tree_model_iter_children (devices_model, &iter, parent);
while (cont) {
GHashTable *services;
DBusGProxy *proxy;
char *alias, *address, **uuids, *name;
gboolean is_connected;
BluetoothType type;
GtkAction *action, *status, *oper;
gtk_tree_model_get (devices_model, &iter,
BLUETOOTH_COLUMN_PROXY, &proxy,
BLUETOOTH_COLUMN_ADDRESS, &address,
BLUETOOTH_COLUMN_SERVICES, &services,
BLUETOOTH_COLUMN_ALIAS, &alias,
BLUETOOTH_COLUMN_UUIDS, &uuids,
BLUETOOTH_COLUMN_TYPE, &type,
-1);
if (device_has_submenu ((const char **) uuids, services, type) == FALSE ||
address == NULL || proxy == NULL || alias == NULL) {
if (proxy != NULL)
g_object_unref (proxy);
if (services != NULL)
g_hash_table_unref (services);
g_strfreev (uuids);
g_free (alias);
g_free (address);
cont = gtk_tree_model_iter_next (devices_model, &iter);
continue;
}
action = gtk_action_group_get_action (devices_action_group, address);
oper = NULL;
status = NULL;
if (action) {
char *action_name;
actions = g_list_remove (actions, action);
action_name = g_strdup_printf ("%s-status", address);
status = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
action_name = g_strdup_printf ("%s-action", address);
oper = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
}
/* If one service is connected, then we're connected */
is_connected = FALSE;
if (services != NULL) {
GList *list, *l;
list = g_hash_table_get_values (services);
for (l = list; l != NULL; l = l->next) {
BluetoothStatus val = GPOINTER_TO_INT (l->data);
if (val == BLUETOOTH_STATUS_CONNECTED ||
val == BLUETOOTH_STATUS_PLAYING) {
is_connected = TRUE;
break;
}
}
g_list_free (list);
}
name = escape_label_for_action (alias);
if (action == NULL) {
guint menu_merge_id;
char *action_path;
/* The menu item with descendants */
action = gtk_action_new (address, name, NULL, NULL);
gtk_action_group_add_action (devices_action_group, action);
g_object_unref (action);
menu_merge_id = gtk_ui_manager_new_merge_id (uimanager);
gtk_ui_manager_add_ui (uimanager, menu_merge_id,
"/bluetooth-applet-popup/devices-placeholder", address, address,
GTK_UI_MANAGER_MENU, FALSE);
g_object_set_data_full (G_OBJECT (action),
"merge-id", GUINT_TO_POINTER (menu_merge_id), NULL);
/* The status menu item */
status = add_menu_item (address,
"status",
is_connected ? _("Connected") : _("Disconnected"),
uimanager,
menu_merge_id,
NULL);
gtk_action_set_sensitive (status, FALSE);
if (services != NULL) {
action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status",
address, address);
action_set_bold (uimanager, status, action_path);
g_free (action_path);
} else {
gtk_action_set_visible (status, FALSE);
}
/* The connect button */
oper = add_menu_item (address,
"action",
is_connected ? _("Disconnect") : _("Connect"),
uimanager,
menu_merge_id,
G_CALLBACK (on_connect_activate));
if (services == NULL)
gtk_action_set_visible (oper, FALSE);
add_separator_item (address, "connect-sep", uimanager, menu_merge_id);
/* The Send to... button */
if (device_has_uuid ((const char **) uuids, "OBEXObjectPush") != FALSE) {
add_menu_item (address,
"sendto",
_("Send files..."),
uimanager,
menu_merge_id,
G_CALLBACK (sendto_callback));
g_object_set_data_full (G_OBJECT (action),
"alias", g_strdup (alias), g_free);
}
if (device_has_uuid ((const char **) uuids, "OBEXFileTransfer") != FALSE) {
add_menu_item (address,
"browse",
_("Browse files..."),
uimanager,
menu_merge_id,
G_CALLBACK (browse_callback));
}
add_separator_item (address, "files-sep", uimanager, menu_merge_id);
if (type == BLUETOOTH_TYPE_KEYBOARD && program_available (KEYBOARD_PREFS)) {
add_menu_item (address,
"keyboard",
_("Open Keyboard Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (keyboard_callback));
}
if (type == BLUETOOTH_TYPE_MOUSE && program_available (MOUSE_PREFS)) {
add_menu_item (address,
"mouse",
_("Open Mouse Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (mouse_callback));
}
if ((type == BLUETOOTH_TYPE_HEADSET ||
type == BLUETOOTH_TYPE_HEADPHONES ||
type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (SOUND_PREFS)) {
add_menu_item (address,
"sound",
_("Open Sound Preferences..."),
uimanager,
menu_merge_id,
G_CALLBACK (sound_callback));
}
} else {
gtk_action_set_label (action, name);
gtk_action_set_visible (status, services != NULL);
gtk_action_set_visible (oper, services != NULL);
if (services != NULL) {
set_device_status_label (address, is_connected ? CONNECTED : DISCONNECTED);
gtk_action_set_label (oper, is_connected ? _("Disconnect") : _("Connect"));
}
}
g_free (name);
if (oper != NULL) {
g_object_set_data_full (G_OBJECT (oper),
"connected", GINT_TO_POINTER (is_connected ? CONNECTED : DISCONNECTED), NULL);
g_object_set_data_full (G_OBJECT (oper),
"device-path", g_strdup (dbus_g_proxy_get_path (proxy)), g_free);
}
/* And now for the trick of the day */
if (is_connected != FALSE) {
char *path;
path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", address);
action_set_bold (uimanager, action, path);
g_free (path);
}
num_devices++;
if (proxy != NULL)
g_object_unref (proxy);
if (services != NULL)
g_hash_table_unref (services);
g_strfreev (uuids);
g_free (alias);
g_free (address);
cont = gtk_tree_model_iter_next (devices_model, &iter);
}
/* Remove the left-over devices */
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
done:
gtk_ui_manager_ensure_update (uimanager);
gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
num_devices > 0);
}
