static void
add_module_to_view_menu(gchar *name, GdkPixbuf *pixbuf)
{
stock_icon_register_pixbuf(pixbuf, name);
GtkActionEntry entries[] = {
{ name, /* name */
name, /* stockid */
name, /* label */
NULL, /* accelerator */
NULL, /* tooltip */
NULL, /* callback */
},
};
gtk_action_group_add_actions(shell->action_group, entries, 1, NULL);
gtk_ui_manager_add_ui(shell->ui_manager,
gtk_ui_manager_new_merge_id(shell->ui_manager),
"/menubar/ViewMenu/LastSep",
name,
name,
GTK_UI_MANAGER_MENU,
TRUE);
}
PRIVATE void ensure_path_exists( char *mpath, char *base ) {
if( !strcmp( mpath, base ) )
return;
GtkWidget *menuaction = gtk_ui_manager_get_widget( ui_manager, mpath );
if( menuaction == NULL ) {
char *updir = g_path_get_dirname( mpath );
char *aname = g_path_get_basename( mpath );
ensure_path_exists( updir, base );
GtkAction *tmpact = gtk_action_new( aname, aname, NULL, NULL );
gtk_action_group_add_action( component_actiongroup, tmpact );
gtk_ui_manager_add_ui( ui_manager,
gtk_ui_manager_new_merge_id( ui_manager ),
updir,
aname,
g_strdup(aname),
GTK_UI_MANAGER_MENU,
TRUE );
//free( aname );
//free( updir );
}
}
static void
windows_menu_dock_window_added (GimpDialogFactory *factory,
GimpDockWindow *dock_window,
GimpUIManager *manager)
{
const gchar *ui_path;
gchar *action_name;
gchar *action_path;
gchar *merge_key;
guint merge_id;
ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");
action_name = windows_actions_dock_window_to_action_name (dock_window);
action_path = g_strdup_printf ("%s/Windows/Docks",
ui_path);
merge_key = windows_menu_dock_window_to_merge_id (dock_window);
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));
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (merge_key);
g_free (action_path);
g_free (action_name);
}
static void
add_module_entry_to_view_menu(gchar *module, gchar *name, GdkPixbuf *pixbuf, GtkTreeIter *iter)
{
stock_icon_register_pixbuf(pixbuf, name);
GtkActionEntry entries[] = {
{ name, /* name */
name, /* stockid */
name, /* label */
NULL, /* accelerator */
NULL, /* tooltip */
(GCallback)view_menu_select_entry,/* callback */
},
};
gtk_action_group_add_actions(shell->action_group, entries, 1, iter);
gtk_ui_manager_add_ui(shell->ui_manager,
gtk_ui_manager_new_merge_id(shell->ui_manager),
g_strdup_printf("/menubar/ViewMenu/%s", module),
name,
name,
GTK_UI_MANAGER_AUTO,
FALSE);
}
static void
composer_setup_charset_menu (EMsgComposer *composer)
{
EHTMLEditor *editor;
GtkUIManager *ui_manager;
const gchar *path;
GList *list;
guint merge_id;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
path = "/main-menu/options-menu/charset-menu";
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
list = gtk_action_group_list_actions (composer->priv->charset_actions);
list = g_list_sort (list, (GCompareFunc) e_action_compare_by_label);
while (list != NULL) {
GtkAction *action = list->data;
gtk_ui_manager_add_ui (
ui_manager, merge_id, path,
gtk_action_get_name (action),
gtk_action_get_name (action),
GTK_UI_MANAGER_AUTO, FALSE);
list = g_list_delete_link (list, list);
}
gtk_ui_manager_ensure_update (ui_manager);
}
/**
* Update the clickable list of closed accounts and target
* accounts to move a transaction, in menu.
*
* \param
* \return FALSE
* */
gboolean gsb_menu_update_accounts_in_menus ( void )
{
GSList *list_tmp;
GtkActionGroup * action_group;
if ( move_to_account_merge_id != -1 )
gtk_ui_manager_remove_ui ( ui_manager, move_to_account_merge_id );
move_to_account_merge_id = gtk_ui_manager_new_merge_id ( ui_manager );
action_group = gtk_action_group_new ( "Group3" );
/* create the closed accounts and accounts in the menu to move a transaction */
list_tmp = gsb_data_account_get_list_accounts ();
while ( list_tmp )
{
gint i;
i = gsb_data_account_get_no_account ( list_tmp -> data );
if ( !gsb_data_account_get_closed_account ( i ) )
{
gchar *tmp_name;
gchar *account_name;
GtkAction *action;
tmp_name = g_strdup_printf ( "MoveToAccount%d", i );
account_name = gsb_data_account_get_name ( i );
if ( !account_name )
account_name = _("Unnamed account");
action = gtk_action_new ( tmp_name, account_name, "", "" );
if ( gsb_gui_navigation_get_current_account () == i )
gtk_action_set_sensitive ( action, FALSE );
gtk_action_group_add_action ( action_group, action );
g_signal_connect ( action,
"activate",
G_CALLBACK ( move_selected_operation_to_account_nb ),
GINT_TO_POINTER ( i ) );
gtk_ui_manager_add_ui ( ui_manager,
move_to_account_merge_id,
"/menubar/EditMenu/MoveToAnotherAccount/",
tmp_name,
tmp_name,
GTK_UI_MANAGER_MENUITEM,
FALSE );
g_free ( tmp_name );
}
list_tmp = list_tmp -> next;
}
gtk_ui_manager_insert_action_group ( ui_manager, action_group, 2 );
gtk_ui_manager_ensure_update ( ui_manager );
return FALSE;
}
static void
windows_menu_recent_add (GimpContainer *container,
GimpSessionInfo *info,
GimpUIManager *manager)
{
const gchar *ui_path;
gchar *action_name;
gchar *action_path;
gint info_id;
gchar *merge_key;
guint merge_id;
ui_path = g_object_get_data (G_OBJECT (manager), "image-menu-ui-path");
info_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info),
"recent-action-id"));
action_name = g_strdup_printf ("windows-recent-%04d", info_id);
action_path = g_strdup_printf ("%s/Windows/Recently Closed Docks", ui_path);
merge_key = g_strdup_printf ("windows-recent-%04d-merge-id", info_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));
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
TRUE);
g_free (merge_key);
g_free (action_path);
g_free (action_name);
}
int vwin_menu_add_item_unique (windata_t *vwin,
const gchar *aname,
const gchar *path,
GtkActionEntry *entry)
{
GList *list = gtk_ui_manager_get_action_groups(vwin->ui);
GtkActionGroup *actions;
guint id;
while (list != NULL) {
GtkActionGroup *group = list->data;
if (!strcmp(aname, gtk_action_group_get_name(group))) {
gtk_ui_manager_remove_action_group(vwin->ui, group);
break;
}
list = list->next;
}
id = gtk_ui_manager_new_merge_id(vwin->ui);
actions = gtk_action_group_new(aname);
gtk_action_group_set_translation_domain(actions, "gretl");
gtk_action_group_add_actions(actions, entry, 1, vwin);
gtk_ui_manager_add_ui(vwin->ui, id, path, entry->name, entry->name,
GTK_UI_MANAGER_MENUITEM, FALSE);
gtk_ui_manager_insert_action_group(vwin->ui, actions, 0);
g_object_unref(actions);
return id;
}
void vwin_menu_add_separator (windata_t *vwin, const gchar *path)
{
guint id = gtk_ui_manager_new_merge_id(vwin->ui);
gtk_ui_manager_add_ui(vwin->ui, id, path, NULL, NULL,
GTK_UI_MANAGER_SEPARATOR, FALSE);
}
void
file_menu_setup (GimpUIManager *manager,
const gchar *ui_path)
{
GtkUIManager *ui_manager;
gint n_entries;
guint merge_id;
gint i;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
ui_manager = GTK_UI_MANAGER (manager);
n_entries = GIMP_GUI_CONFIG (manager->gimp->config)->last_opened_size;
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
for (i = 0; i < n_entries; i++)
{
gchar *action_name;
gchar *action_path;
action_name = g_strdup_printf ("file-open-recent-%02d", i + 1);
action_path = g_strdup_printf ("%s/File/Open Recent/Files", ui_path);
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);
}
}
int vwin_menu_add_items (windata_t *vwin, const gchar *path,
GtkActionEntry *entries, int n)
{
GtkActionGroup *actions;
int newgroup = 1;
guint id;
int i;
actions = get_ad_hoc_group(vwin->ui, &newgroup);
gtk_action_group_add_actions(actions, entries, n, vwin);
id = gtk_ui_manager_new_merge_id(vwin->ui);
for (i=0; i<n; i++) {
gtk_ui_manager_add_ui(vwin->ui, id, path,
entries[i].name, entries[i].name,
GTK_UI_MANAGER_MENUITEM, FALSE);
}
if (newgroup) {
gtk_ui_manager_insert_action_group(vwin->ui, actions, 0);
g_object_unref(actions);
}
return id;
}
static struct menu_priv *
add_menu(struct menu_priv *menu, struct menu_methods *meth, char *name, enum menu_type type, void (*callback)(struct menu *data_menu, void *data1, void *data2), struct menu *data_menu, void *data1, void *data2)
{
struct menu_priv *ret;
char *dynname;
ret=g_new0(struct menu_priv, 1);
*meth=menu_methods;
if (! strcmp(menu->path, "/ui/MenuBar") && !strcmp(name,"Route")) {
dynname=g_strdup("Route");
} else {
dynname=g_strdup_printf("%d", menu->gui->dyn_counter++);
if (type == menu_type_toggle)
ret->action=GTK_ACTION(gtk_toggle_action_new(dynname, name, NULL, NULL));
else
ret->action=gtk_action_new(dynname, name, NULL, NULL);
if (callback)
ret->handler_id=g_signal_connect(ret->action, "activate", G_CALLBACK(activate), ret);
gtk_action_group_add_action(menu->gui->dyn_group, ret->action);
ret->merge_id=gtk_ui_manager_new_merge_id(menu->gui->menu_manager);
gtk_ui_manager_add_ui( menu->gui->menu_manager, ret->merge_id, menu->path, dynname, dynname, type == menu_type_submenu ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM, FALSE);
}
ret->gui=menu->gui;
ret->path=g_strdup_printf("%s/%s", menu->path, dynname);
ret->type=type;
ret->callback=callback;
ret->callback_menu=data_menu;
ret->callback_data1=data1;
ret->callback_data2=data2;
ret->sibling=menu->child;
menu->child=ret;
g_free(dynname);
return ret;
}
static void
impl_attach_window (EphyExtension *ext,
EphyWindow *window)
{
LOG ("EphyJavaConsoleExtension attach_window");
if (java_console_is_available ())
{
GtkUIManager *manager;
WindowData *data;
data = g_new0 (WindowData, 1);
g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY, data,
(GDestroyNotify) g_free);
data->action_group = gtk_action_group_new ("EphyJCExtActions");
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), window);
manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
gtk_ui_manager_insert_action_group (manager, data->action_group, 0);
g_object_unref (data->action_group);
data->merge_id = gtk_ui_manager_new_merge_id (manager);
gtk_ui_manager_add_ui (manager, data->merge_id, "/menubar/ToolsMenu",
ACTION_NAME_SHOW_CONSOLE, ACTION_NAME_SHOW_CONSOLE,
GTK_UI_MANAGER_MENUITEM, FALSE);
}
}
void
nautilus_navigation_window_load_extension_toolbar_items (NautilusNavigationWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
GtkUIManager *ui_manager;
GList *items;
GList *l;
NautilusMenuItem *item;
guint merge_id;
ui_manager = nautilus_window_get_ui_manager (NAUTILUS_WINDOW (window));
if (window->details->extensions_toolbar_merge_id != 0) {
gtk_ui_manager_remove_ui (ui_manager,
window->details->extensions_toolbar_merge_id);
window->details->extensions_toolbar_merge_id = 0;
}
if (window->details->extensions_toolbar_action_group != NULL) {
gtk_ui_manager_remove_action_group (ui_manager,
window->details->extensions_toolbar_action_group);
window->details->extensions_toolbar_action_group = NULL;
}
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
window->details->extensions_toolbar_merge_id = merge_id;
action_group = gtk_action_group_new ("ExtensionsToolbarGroup");
window->details->extensions_toolbar_action_group = action_group;
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_ui_manager_insert_action_group (ui_manager, action_group, -1);
g_object_unref (action_group); /* owned by ui manager */
items = get_extension_toolbar_items (window);
for (l = items; l != NULL; l = l->next) {
item = NAUTILUS_MENU_ITEM (l->data);
action = nautilus_toolbar_action_from_menu_item (item);
gtk_action_group_add_action (action_group,
GTK_ACTION (action));
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
merge_id,
TOOLBAR_PATH_EXTENSION_ACTIONS,
gtk_action_get_name (action),
gtk_action_get_name (action),
GTK_UI_MANAGER_TOOLITEM,
FALSE);
g_object_unref (item);
}
g_list_free (items);
}
static void create_jump_to_menu(GebrGeoXmlObject * object, GebrGuiHelpEditWindow * window)
{
guint merge_id;
GtkAction * action;
GtkUIManager * manager;
GtkActionGroup * group;
GebrGeoXmlFlow * flow;
GebrGeoXmlSequence * program;
gchar * jumpto_path;
manager = gebr_gui_help_edit_window_get_ui_manager(window);
// Remove old action group and merge_id from the window and insert the new ones
//
group = g_object_get_data(G_OBJECT(window), JUMP_TO_ACTION_GROUP);
merge_id = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(window), JUMP_TO_MERGE_ID));
if (group != NULL) {
gtk_ui_manager_remove_action_group(manager, group);
gtk_ui_manager_remove_ui(manager, merge_id);
}
group = gtk_action_group_new(JUMP_TO_ACTION_GROUP);
merge_id = gtk_ui_manager_new_merge_id(manager);
g_object_set_data(G_OBJECT(window), JUMP_TO_ACTION_GROUP, group);
g_object_set_data(G_OBJECT(window), JUMP_TO_MERGE_ID, GUINT_TO_POINTER(merge_id));
// Calculates the path for JumpToMenu
//
jumpto_path = g_strconcat(gebr_gui_help_edit_window_get_menu_bar_path(window), "/JumpToMenu", NULL);
if (gebr_geoxml_object_get_type(object) == GEBR_GEOXML_OBJECT_TYPE_PROGRAM)
flow = GEBR_GEOXML_FLOW(gebr_geoxml_object_get_owner_document(object));
else
flow = GEBR_GEOXML_FLOW(object);
gtk_ui_manager_insert_action_group(manager, group, 0);
action = insert_jump_to_action(GEBR_GEOXML_OBJECT(flow), window, group,
manager, jumpto_path, merge_id);
if (GEBR_GEOXML_OBJECT(flow) == object)
gtk_action_set_sensitive(action, FALSE);
gtk_ui_manager_add_ui(manager, merge_id, jumpto_path,
"JumpToSep", NULL, GTK_UI_MANAGER_SEPARATOR, FALSE);
gebr_geoxml_flow_get_program(flow, &program, 0);
while (program) {
action = insert_jump_to_action(GEBR_GEOXML_OBJECT(program), window, group,
manager, jumpto_path, merge_id);
if (GEBR_GEOXML_OBJECT(program) == object)
gtk_action_set_sensitive(action, FALSE);
gebr_geoxml_sequence_next(&program);
}
g_free(jumpto_path);
}
static void
update_bookmarks (CajaWindow *window)
{
CajaBookmarkList *bookmarks;
CajaBookmark *bookmark;
guint bookmark_count;
guint index;
GtkUIManager *ui_manager;
g_assert (CAJA_IS_WINDOW (window));
g_assert (window->details->bookmarks_merge_id == 0);
g_assert (window->details->bookmarks_action_group == NULL);
if (window->details->bookmark_list == NULL)
{
window->details->bookmark_list = caja_bookmark_list_new ();
}
bookmarks = window->details->bookmark_list;
ui_manager = caja_window_get_ui_manager (CAJA_WINDOW (window));
window->details->bookmarks_merge_id = gtk_ui_manager_new_merge_id (ui_manager);
window->details->bookmarks_action_group = gtk_action_group_new ("BookmarksGroup");
g_signal_connect (window->details->bookmarks_action_group, "connect-proxy",
G_CALLBACK (connect_proxy_cb), NULL);
gtk_ui_manager_insert_action_group (ui_manager,
window->details->bookmarks_action_group,
-1);
g_object_unref (window->details->bookmarks_action_group);
/* append new set of bookmarks */
bookmark_count = caja_bookmark_list_length (bookmarks);
for (index = 0; index < bookmark_count; ++index)
{
bookmark = caja_bookmark_list_item_at (bookmarks, index);
if (caja_bookmark_uri_known_not_to_exist (bookmark))
{
continue;
}
caja_menus_append_bookmark_to_menu
(CAJA_WINDOW (window),
bookmark,
CAJA_WINDOW_GET_CLASS (window)->bookmarks_placeholder,
"dynamic",
index,
window->details->bookmarks_action_group,
window->details->bookmarks_merge_id,
G_CALLBACK (refresh_bookmarks_menu),
show_bogus_bookmark_window);
}
}
void
nautilus_ui_prepare_merge_ui (GtkUIManager *ui_manager,
const char *name,
guint *merge_id,
GtkActionGroup **action_group)
{
*merge_id = gtk_ui_manager_new_merge_id (ui_manager);
*action_group = gtk_action_group_new (name);
gtk_action_group_set_translation_domain (*action_group, GETTEXT_PACKAGE);
gtk_ui_manager_insert_action_group (ui_manager, *action_group, 0);
g_object_unref (*action_group); /* owned by ui manager */
}
static void
empathy_mic_menu_update (EmpathyMicMenu *self)
{
EmpathyMicMenuPrivate *priv = self->priv;
GList *l;
GtkUIManager *ui_manager;
EmpathyGstAudioSrc *audio;
guint current_mic;
ui_manager = empathy_call_window_get_ui_manager (priv->window);
audio = empathy_call_window_get_audio_src (priv->window);
current_mic = empathy_audio_src_get_microphone (audio);
empathy_mic_menu_clean (self);
priv->ui_id = gtk_ui_manager_new_merge_id (ui_manager);
for (l = priv->microphones->head; l != NULL; l = l->next)
{
GtkRadioAction *action = l->data;
const gchar *name = gtk_action_get_name (GTK_ACTION (action));
gint value;
gboolean active;
g_object_get (action, "value", &value, NULL);
active = (value == (gint) current_mic);
if (active)
{
priv->in_update = TRUE;
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
priv->in_update = FALSE;
}
/* If action is a monitor then don't show it in the UI, BUT do
* display it regardless if it is the current device. This is so
* we don't have a rubbish UI by showing monitor devices in
* Empathy, but still show the correct device when someone plays
* with pavucontrol. */
if (g_object_get_data (G_OBJECT (action), MONITOR_KEY) != NULL
&& !active)
continue;
gtk_ui_manager_add_ui (ui_manager, priv->ui_id,
/* TODO: this should probably be passed from the call
* window, seeing that it's a reference to
* empathy-call-window.ui. */
"/menubar1/edit/menumicrophone",
name, name, GTK_UI_MANAGER_MENUITEM, FALSE);
}
}
static void
update_bookmarks (AthenaWindow *window)
{
AthenaBookmarkList *bookmarks;
AthenaBookmark *bookmark;
guint bookmark_count;
guint index;
GtkUIManager *ui_manager;
g_assert (ATHENA_IS_WINDOW (window));
g_assert (window->details->bookmarks_merge_id == 0);
g_assert (window->details->bookmarks_action_group == NULL);
if (window->details->bookmark_list == NULL) {
window->details->bookmark_list = athena_bookmark_list_new ();
}
bookmarks = window->details->bookmark_list;
ui_manager = athena_window_get_ui_manager (ATHENA_WINDOW (window));
window->details->bookmarks_merge_id = gtk_ui_manager_new_merge_id (ui_manager);
window->details->bookmarks_action_group = gtk_action_group_new ("BookmarksGroup");
g_signal_connect (window->details->bookmarks_action_group, "connect-proxy",
G_CALLBACK (connect_proxy_cb), NULL);
gtk_ui_manager_insert_action_group (ui_manager,
window->details->bookmarks_action_group,
-1);
g_object_unref (window->details->bookmarks_action_group);
/* append new set of bookmarks */
bookmark_count = athena_bookmark_list_length (bookmarks);
for (index = 0; index < bookmark_count; ++index) {
bookmark = athena_bookmark_list_item_at (bookmarks, index);
if (athena_bookmark_uri_known_not_to_exist (bookmark)) {
continue;
}
athena_menus_append_bookmark_to_menu
(ATHENA_WINDOW (window),
bookmark,
MENU_PATH_BOOKMARKS_PLACEHOLDER,
"dynamic",
index,
window->details->bookmarks_action_group,
window->details->bookmarks_merge_id,
G_CALLBACK (refresh_bookmarks_menu),
show_bogus_bookmark_window);
}
}
static void
impl_activate (PeasActivatable *plugin)
{
GtkWindow *window;
GtkUIManager *manager;
XplayerSkiptoPlugin *pi = XPLAYER_SKIPTO_PLUGIN (plugin);
XplayerSkiptoPluginPrivate *priv = pi->priv;
const GtkActionEntry menu_entries[] = {
{ "skip-to", "go-jump-symbolic", N_("_Skip To..."), "<Control>K", N_("Skip to a specific time"), G_CALLBACK (skip_to_action_callback) }
};
priv->xplayer = g_object_get_data (G_OBJECT (plugin), "object");
priv->handler_id_stream_length = g_signal_connect (G_OBJECT (priv->xplayer),
"notify::stream-length",
G_CALLBACK (property_notify_cb),
pi);
priv->handler_id_seekable = g_signal_connect (G_OBJECT (priv->xplayer),
"notify::seekable",
G_CALLBACK (property_notify_cb),
pi);
/* Key press handler */
window = xplayer_get_main_window (priv->xplayer);
priv->handler_id_key_press = g_signal_connect (G_OBJECT(window),
"key-press-event",
G_CALLBACK (on_window_key_press_event),
pi);
g_object_unref (window);
/* Install the menu */
priv->action_group = gtk_action_group_new ("skip-to_group");
gtk_action_group_set_translation_domain (priv->action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (priv->action_group, menu_entries,
G_N_ELEMENTS (menu_entries), pi);
manager = xplayer_get_ui_manager (priv->xplayer);
gtk_ui_manager_insert_action_group (manager, priv->action_group, -1);
g_object_unref (priv->action_group);
priv->ui_merge_id = gtk_ui_manager_new_merge_id (manager);
gtk_ui_manager_add_ui (manager, priv->ui_merge_id,
"/ui/tmw-menubar/go/skip-forward", "skip-to",
"skip-to", GTK_UI_MANAGER_AUTO, TRUE);
xplayer_skipto_update_from_state (priv->xplayer, pi);
}
static void
build_menu (GaleonEncodingMenu *menu, GList *recent, GList *related)
{
GaleonEncodingMenuPrivate *p = menu->priv;
/* clear the menu */
if (p->merge_id > 0)
{
gtk_ui_manager_remove_ui (p->merge, p->merge_id);
gtk_ui_manager_ensure_update (p->merge);
}
/* build the new menu */
p->merge_id = gtk_ui_manager_new_merge_id (p->merge);
gtk_ui_manager_add_ui (p->merge, p->merge_id,
ENCODING_PLACEHOLDER_PATH,
"ViewEncodingAutomaticItem",
"ViewEncodingAutomatic",
GTK_UI_MANAGER_MENUITEM, FALSE);
gtk_ui_manager_add_ui (p->merge, p->merge_id,
ENCODING_PLACEHOLDER_PATH,
"Sep1Item", "Sep1",
GTK_UI_MANAGER_SEPARATOR, FALSE);
g_list_foreach (recent, (GFunc) add_menu_item, menu);
gtk_ui_manager_add_ui (p->merge, p->merge_id,
ENCODING_PLACEHOLDER_PATH,
"Sep2Item", "Sep2",
GTK_UI_MANAGER_SEPARATOR, FALSE);
g_list_foreach (related, (GFunc) add_menu_item, menu);
gtk_ui_manager_add_ui (p->merge, p->merge_id,
ENCODING_PLACEHOLDER_PATH,
"Sep3Item", "Sep3",
GTK_UI_MANAGER_SEPARATOR, FALSE);
gtk_ui_manager_add_ui (p->merge, p->merge_id,
ENCODING_PLACEHOLDER_PATH,
"ViewEncodingOtherItem",
"ViewEncodingOther",
GTK_UI_MANAGER_MENUITEM, FALSE);
}
static gboolean remmina_main_add_tool_plugin(gchar *name, RemminaPlugin *plugin, gpointer data)
{
RemminaMain *remminamain = REMMINA_MAIN(data);
guint merge_id;
GtkAction *action;
merge_id = gtk_ui_manager_new_merge_id(remminamain->priv->uimanager);
action = gtk_action_new(name, plugin->description, NULL, NULL);
gtk_action_group_add_action(remminamain->priv->main_group, action);
g_signal_connect(G_OBJECT(action), "activate", G_CALLBACK(remmina_main_action_tools_addition), remminamain);
g_object_unref(action);
gtk_ui_manager_add_ui(remminamain->priv->uimanager, merge_id, "/MenuBar/ToolsMenu/ToolsAdditions", name, name,
GTK_UI_MANAGER_MENUITEM, FALSE);
return FALSE;
}
static void
impl_attach_window (EphyExtension *extension,
EphyWindow *window)
{
SoupFlyCBData *cb_data;
GtkActionGroup *action_group;
GtkUIManager *manager;
guint merge_id;
WindowData *data;
EphySoupFlyExtensionPrivate *priv = EPHY_SOUP_FLY_EXTENSION (extension)->priv;
LOG ("EphySoupFlyExtension attach_window");
cb_data = g_new (SoupFlyCBData, 1);
cb_data->extension = EPHY_SOUP_FLY_EXTENSION (extension);
cb_data->window = window;
data = g_new (WindowData, 1);
data->action_group = action_group =
gtk_action_group_new ("EphySoupFlyExtensionActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions_full (action_group, action_entries,
G_N_ELEMENTS (action_entries), cb_data,
g_free);
manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
gtk_ui_manager_insert_action_group (manager, action_group, 0);
data->ui_id = merge_id = gtk_ui_manager_new_merge_id (manager);
g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY, data,
(GDestroyNotify) free_window_data);
gtk_ui_manager_add_ui (manager, merge_id, "/ui/PagePopup/ExtensionsMenu",
"SoupFlySep", NULL,
GTK_UI_MANAGER_SEPARATOR, FALSE);
gtk_ui_manager_add_ui (manager, merge_id, "/ui/PagePopup/ExtensionsMenu",
"SoupFly", "SoupFly",
GTK_UI_MANAGER_MENUITEM, FALSE);
if (priv->is_logging == FALSE) {
soup_fly_start (priv->fly);
priv->is_logging = TRUE;
}
}
static void
impl_activate (CeditPlugin *plugin,
CeditWindow *window)
{
GtkUIManager *manager;
WindowData *data;
cedit_debug (DEBUG_PLUGINS);
data = g_new (WindowData, 1);
data->plugin = g_object_ref (plugin);
data->dialog = NULL;
data->ui_action_group = gtk_action_group_new ("CeditDocInfoPluginActions");
gtk_action_group_set_translation_domain (data->ui_action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (data->ui_action_group,
action_entries,
G_N_ELEMENTS (action_entries),
window);
manager = cedit_window_get_ui_manager (window);
gtk_ui_manager_insert_action_group (manager,
data->ui_action_group,
-1);
data->ui_id = gtk_ui_manager_new_merge_id (manager);
g_object_set_data_full (G_OBJECT (window),
WINDOW_DATA_KEY,
data,
(GDestroyNotify) free_window_data);
gtk_ui_manager_add_ui (manager,
data->ui_id,
MENU_PATH,
"DocumentStatistics",
"DocumentStatistics",
GTK_UI_MANAGER_MENUITEM,
FALSE);
update_ui_real (window,
data);
}
int
clip_GTK_UIMANAGERNEWMERGEID(ClipMachine * ClipMachineMemory)
{
C_object *cmanager = _fetch_co_arg(ClipMachineMemory);
guint ret;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cmanager, GTK_IS_UI_MANAGER(cmanager->object));
ret = gtk_ui_manager_new_merge_id(GTK_UI_MANAGER(cmanager->object));
_clip_retni(ClipMachineMemory, ret);
return 0;
err:
return 1;
}
void
menus_set_recent (GtkActionGroup *actions)
{
GList *list;
guint id;
const char *recent_path;
if (is_integrated_ui ())
recent_path = INTEGRATED_MENU "/File/FileRecentEnd";
else
recent_path = TOOLBOX_MENU "/File/FileRecentEnd";
if (recent_actions) {
menus_clear_recent ();
}
list = gtk_action_group_list_actions (actions);
g_return_if_fail (list);
/* sort it by the action name to preserve out order */
list = g_list_sort (list, cmp_action_names);
recent_actions = actions;
g_object_ref (G_OBJECT (recent_actions));
gtk_ui_manager_insert_action_group (_ui_manager,
recent_actions,
10 /* insert at back */ );
do {
const gchar* aname = gtk_action_get_name (GTK_ACTION (list->data));
id = gtk_ui_manager_new_merge_id (_ui_manager);
recent_merge_ids = g_slist_prepend (recent_merge_ids, GUINT_TO_POINTER (id));
gtk_ui_manager_add_ui (_ui_manager, id,
recent_path,
aname,
aname,
GTK_UI_MANAGER_AUTO,
TRUE);
} while (NULL != (list = list->next));
}
/**
* refresh_go_menu:
*
* Refresh list of bookmarks at end of Go menu to match centralized history list.
* @window: The NautilusWindow whose Go menu will be refreshed.
**/
static void
refresh_go_menu (NautilusNavigationWindow *window)
{
GtkUIManager *ui_manager;
GList *node;
int index;
g_assert (NAUTILUS_IS_NAVIGATION_WINDOW (window));
/* Unregister any pending call to this function. */
nautilus_navigation_window_remove_go_menu_callback (window);
/* Remove old set of history items. */
nautilus_navigation_window_remove_go_menu_items (window);
ui_manager = nautilus_window_get_ui_manager (NAUTILUS_WINDOW (window));
window->details->go_menu_merge_id = gtk_ui_manager_new_merge_id (ui_manager);
window->details->go_menu_action_group = gtk_action_group_new ("GoMenuGroup");
g_signal_connect (window->details->go_menu_action_group, "connect-proxy",
G_CALLBACK (connect_proxy_cb), NULL);
gtk_ui_manager_insert_action_group (ui_manager,
window->details->go_menu_action_group,
-1);
g_object_unref (window->details->go_menu_action_group);
/* Add in a new set of history items. */
for (node = nautilus_get_history_list (), index = 0;
node != NULL && index < 10;
node = node->next, index++) {
nautilus_menus_append_bookmark_to_menu
(NAUTILUS_WINDOW (window),
NAUTILUS_BOOKMARK (node->data),
MENU_PATH_HISTORY_PLACEHOLDER,
"history",
index,
window->details->go_menu_action_group,
window->details->go_menu_merge_id,
G_CALLBACK (schedule_refresh_go_menu),
show_bogus_history_window);
}
}
PUBLIC void comp_create_action( char *menuitem, ComponentClass *k, gpointer init_data, char *name, char *label )
{
char *long_name = g_path_get_basename( menuitem );
char *base = "/ui/MainMenu/AddComp";
char *mpath = g_strdup_printf( "%s/%s", base, menuitem );
// GtkAction *action = g_object_new( COMPACTION_TYPE,
// "component-class", k,
// "init-data", init_data,
GtkAction *action = g_object_new( GALAN_TYPE_COMPACTION,
"klass", k,
"init_data", init_data,
"name", g_strdup(name),
"label", long_name,
"short-label", g_strdup(name),
"hide-if-empty", FALSE,
NULL );
gtk_action_group_add_action( component_actiongroup, action );
char *dir_path = g_path_get_dirname( mpath);
ensure_path_exists( dir_path, base );
//XXX: the half baked tree model
GtkTreeIter iter;
galan_comptree_model_lookup( tmodel, menuitem, &iter, TRUE );
gtk_tree_store_set( GTK_TREE_STORE(tmodel), &iter, 1, TRUE, 2, action, -1 );
//XXX:
//printf( "name = %s\n", gtk_action_get_name( action ) );
gtk_ui_manager_add_ui( ui_manager,
gtk_ui_manager_new_merge_id( ui_manager ),
dir_path,
name,
name,
GTK_UI_MANAGER_MENUITEM,
TRUE );
}
static void
impl_attach_window (EphyExtension *ext,
EphyWindow *window)
{
GtkUIManager *manager;
GtkActionGroup *action_group;
guint ui_id;
WindowData *data;
LOG ("EphyGreasemonkeyExtension attach_window");
data = g_new0 (WindowData, 1);
manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
data->action_group = action_group =
gtk_action_group_new ("EphyGreasemonkeyExtensionActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group, action_entries,
G_N_ELEMENTS (action_entries), window);
gtk_ui_manager_insert_action_group (manager, action_group, 0);
data->ui_id = ui_id = gtk_ui_manager_new_merge_id (manager);
data->window = window;
g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY, data,
(GDestroyNotify) free_window_data);
gtk_ui_manager_add_ui (manager, ui_id, "/EphyLinkPopup",
"GreasemonkeySep1", NULL,
GTK_UI_MANAGER_SEPARATOR, TRUE);
gtk_ui_manager_add_ui (manager, ui_id, "/EphyLinkPopup",
ACTION_NAME, ACTION_NAME,
GTK_UI_MANAGER_MENUITEM, TRUE);
gtk_ui_manager_add_ui (manager, ui_id, "/EphyLinkPopup",
"GreasemonkeySep2", NULL,
GTK_UI_MANAGER_SEPARATOR, TRUE);
}
/** Initialize the report menu and other additional menus. This
* function is called as part of the initialization of a window, when
* the plugin menu items are being added to the menu structure.
*
* @param plugin A pointer to the gnc-plugin object responsible for
* adding/removing the additional menu items.
*
* @param window A pointer the gnc-main-window where this plugin
* should add its actions.
*
* @param type Unused
*/
static void
gnc_plugin_menu_additions_add_to_window (GncPlugin *plugin,
GncMainWindow *window,
GQuark type)
{
GncPluginMenuAdditionsPerWindow per_window;
static GOnce accel_table_init = G_ONCE_INIT;
static GHashTable *table;
GSList *menu_list;
ENTER(" ");
per_window.window = window;
per_window.ui_manager = window->ui_merge;
per_window.group = gtk_action_group_new ("MenuAdditions" );
gnc_gtk_action_group_set_translation_domain (per_window.group, GETTEXT_PACKAGE);
per_window.merge_id = gtk_ui_manager_new_merge_id(window->ui_merge);
gtk_ui_manager_insert_action_group(window->ui_merge, per_window.group, 0);
menu_list = g_slist_sort(gnc_extensions_get_menu_list(),
(GCompareFunc)gnc_menu_additions_sort);
/* Assign accelerators */
table = g_once(&accel_table_init, gnc_menu_additions_init_accel_table, NULL);
g_slist_foreach(menu_list,
(GFunc)gnc_menu_additions_do_preassigned_accel, table);
g_slist_foreach(menu_list, (GFunc)gnc_menu_additions_assign_accel, table);
/* Add to window. */
g_slist_foreach(menu_list, (GFunc)gnc_menu_additions_menu_setup_one,
&per_window);
/* Tell the window code about the actions that were just added
* behind its back (so to speak) */
gnc_main_window_manual_merge_actions (window, PLUGIN_ACTIONS_NAME,
per_window.group, per_window.merge_id);
g_slist_free(menu_list);
LEAVE(" ");
}
