static gboolean activate_plugin(AnjutaPlugin *plugin) {
AnjutaUI *ui;
PlaylistDisplayPlugin *playlist_display_plugin;
GtkActionGroup* action_group;
GtkAction *new_playlist_action;
GtkAction *load_ipods_action;
/* Set preferences */
set_default_preferences();
/* Prepare the icons for the playlist */
register_icon_path(get_plugin_dir(), "playlist_display");
register_stock_icon(PREFERENCE_ICON, PREFERENCE_ICON_STOCK_ID);
register_stock_icon("playlist_display-photo", PLAYLIST_DISPLAY_PHOTO_ICON_STOCK_ID);
register_stock_icon("playlist_display-playlist", PLAYLIST_DISPLAY_PLAYLIST_ICON_STOCK_ID);
register_stock_icon("playlist_display-read", PLAYLIST_DISPLAY_READ_ICON_STOCK_ID);
register_stock_icon("playlist_display-add-dirs", PLAYLIST_DISPLAY_ADD_DIRS_ICON_STOCK_ID);
register_stock_icon("playlist_display-add-files", PLAYLIST_DISPLAY_ADD_FILES_ICON_STOCK_ID);
register_stock_icon("playlist_display-add-playlists", PLAYLIST_DISPLAY_ADD_PLAYLISTS_ICON_STOCK_ID);
register_stock_icon("playlist_display-sync", PLAYLIST_DISPLAY_SYNC_ICON_STOCK_ID);
playlist_display_plugin = (PlaylistDisplayPlugin*) plugin;
ui = anjuta_shell_get_ui(plugin->shell, NULL);
/* Add our playlist_actions */
action_group
= anjuta_ui_add_action_group_entries(ui, "ActionGroupPlaylistDisplay", _("Playlist Display"), playlist_actions, G_N_ELEMENTS (playlist_actions), GETTEXT_PACKAGE, TRUE, plugin);
playlist_display_plugin->action_group = action_group;
new_playlist_action = tool_menu_action_new (ACTION_NEW_PLAYLIST, _("New Playlist"), _("Create a new playlist for the selected iPod"), GTK_STOCK_NEW);
g_signal_connect(new_playlist_action, "activate", G_CALLBACK(on_new_playlist_activate), NULL);
gtk_action_group_add_action (playlist_display_plugin->action_group, GTK_ACTION (new_playlist_action));
load_ipods_action = tool_menu_action_new (ACTION_DISPLAY_LOAD_IPODS, _("Load iPods"), _("Load all or selected iPods"), PLAYLIST_DISPLAY_READ_ICON_STOCK_ID);
g_signal_connect(load_ipods_action, "activate", G_CALLBACK(on_load_ipods_mi), NULL);
gtk_action_group_add_action (playlist_display_plugin->action_group, GTK_ACTION (load_ipods_action));
/* Merge UI */
gchar *uipath = g_build_filename(get_ui_dir(), "playlist_display.ui", NULL);
playlist_display_plugin->uiid = anjuta_ui_merge(ui, uipath);
g_free(uipath);
playlist_display_plugin->playlist_view = pm_create_playlist_view(action_group);
g_signal_connect (gtkpod_app, SIGNAL_PLAYLIST_ADDED, G_CALLBACK (playlist_display_playlist_added_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_PLAYLIST_REMOVED, G_CALLBACK (playlist_display_playlist_removed_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_ITDB_ADDED, G_CALLBACK (playlist_display_itdb_added_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_ITDB_REMOVED, G_CALLBACK (playlist_display_itdb_removed_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_ITDB_UPDATED, G_CALLBACK (playlist_display_update_itdb_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_PREFERENCE_CHANGE, G_CALLBACK (playlist_display_preference_changed_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_ITDB_DATA_CHANGED, G_CALLBACK (playlist_display_itdb_data_changed_cb), NULL);
g_signal_connect (gtkpod_app, SIGNAL_ITDB_DATA_SAVED, G_CALLBACK (playlist_display_itdb_data_changed_cb), NULL);
gtk_widget_show_all(playlist_display_plugin->playlist_view);
// Add widget directly as scrolling is handled internally by the widget
anjuta_shell_add_widget(plugin->shell, playlist_display_plugin->playlist_view, "PlaylistDisplayPlugin", _(" iPod Repositories"), PLAYLIST_DISPLAY_PLAYLIST_ICON_STOCK_ID, ANJUTA_SHELL_PLACEMENT_LEFT, NULL);
return TRUE; /* FALSE if activation failed */
}
GtkActionGroup *
nautilus_window_create_toolbar_action_group (NautilusWindow *window)
{
NautilusNavigationState *navigation_state;
GtkActionGroup *action_group;
GtkAction *action;
action_group = gtk_action_group_new ("ToolbarActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION,
"name", NAUTILUS_ACTION_BACK,
"label", _("_Back"),
"stock_id", GTK_STOCK_GO_BACK,
"tooltip", _("Go to the previous visited location"),
"arrow-tooltip", _("Back history"),
"window", window,
"direction", NAUTILUS_NAVIGATION_DIRECTION_BACK,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_back_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION,
"name", NAUTILUS_ACTION_FORWARD,
"label", _("_Forward"),
"stock_id", GTK_STOCK_GO_FORWARD,
"tooltip", _("Go to the next visited location"),
"arrow-tooltip", _("Forward history"),
"window", window,
"direction", NAUTILUS_NAVIGATION_DIRECTION_FORWARD,
"sensitive", FALSE,
NULL);
g_signal_connect (action, "activate",
G_CALLBACK (action_forward_callback), window);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
action = GTK_ACTION
(gtk_toggle_action_new (NAUTILUS_ACTION_SEARCH,
_("Search"),
_("Search documents and folders by name"),
NULL));
gtk_action_group_add_action (action_group, action);
gtk_action_set_icon_name (GTK_ACTION (action), "edit-find-symbolic");
gtk_action_set_is_important (GTK_ACTION (action), TRUE);
g_object_unref (action);
navigation_state = nautilus_window_get_navigation_state (window);
nautilus_navigation_state_add_group (navigation_state, action_group);
return action_group;
}
/**
* 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;
}
void vik_ext_tools_add_action_items ( VikWindow *vwindow, GtkUIManager *uim, GtkActionGroup *action_group, guint mid )
{
GList *iter;
for (iter = ext_tools_list; iter; iter = iter->next)
{
VikExtTool *ext_tool = NULL;
gchar *label = NULL;
ext_tool = VIK_EXT_TOOL ( iter->data );
label = vik_ext_tool_get_label ( ext_tool );
if ( label )
{
gtk_ui_manager_add_ui ( uim, mid, "/ui/MainMenu/Tools/Exttools",
_(label),
label,
GTK_UI_MANAGER_MENUITEM, FALSE );
GtkAction *action = gtk_action_new ( label, label, NULL, NULL );
g_object_set_data ( G_OBJECT(action), VIK_TOOL_DATA_KEY, ext_tool );
g_signal_connect ( G_OBJECT(action), "activate", G_CALLBACK(ext_tools_open_cb), vwindow );
gtk_action_group_add_action ( action_group, action );
g_object_unref ( action );
g_free ( label ); label = NULL;
}
}
}
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
node_added_cb (EphyNode *parent,
EphyNode *child,
GtkActionGroup *action_group)
{
GObject *action_object;
GtkAction *action;
char name[EPHY_OPEN_TABS_ACTION_NAME_BUFFER_SIZE];
char accel[256];
EPHY_OPEN_TABS_ACTION_NAME_PRINTF (name, child);
/* FIXME !!!! */
action = gtk_action_new (name, _("Open in New _Tabs"),
_("Open the bookmarks in this topic in new tabs"), NULL);
action_object = (GObject *)action;
g_object_set_data (action_object, "ephy-node", child);
g_object_set_data (action_object, "ephy-link", EPHY_LINK (action_group));
g_signal_connect (action, "activate",
G_CALLBACK (activate_cb), NULL);
g_snprintf (accel, sizeof (accel), "<Actions>/%s/%s",
gtk_action_group_get_name (action_group),
name);
gtk_action_set_accel_path (action, accel);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
}
static GtkAction * insert_jump_to_action(GebrGeoXmlObject * object,
GebrGuiHelpEditWindow * window,
GtkActionGroup * action_group,
GtkUIManager * ui_manager,
const gchar * jump_to_path,
guint merge_id)
{
gchar * label;
const gchar * title;
GtkAction * action;
if (gebr_geoxml_object_get_type(object) == GEBR_GEOXML_OBJECT_TYPE_PROGRAM) {
title = gebr_geoxml_program_get_title(GEBR_GEOXML_PROGRAM(object));
label = g_strdup_printf(_("Program: %s"), title);
} else {
title = gebr_geoxml_document_get_title(GEBR_GEOXML_DOCUMENT(object));
label = g_strdup_printf(_("Menu: %s"), title);
}
action = g_object_new(GTK_TYPE_ACTION,
"name", label,
"label", label,
NULL);
gtk_action_group_add_action(action_group, action);
g_signal_connect_swapped(action, "activate", G_CALLBACK(debr_help_edit), object);
gtk_ui_manager_add_ui(ui_manager, merge_id, jump_to_path,
label, label, GTK_UI_MANAGER_MENUITEM, FALSE);
g_free(label);
return action;
}
static GtkAction*
add_action (const GaleonEncodingInfo *info, GaleonEncodingMenu *menu)
{
GtkAction *action;
char name[128], *tooltip;
g_snprintf (name, sizeof (name), "Encoding%s", info->encoding);
tooltip = g_strdup_printf (_("Display the page using the \"%s\" encoding"),
info->encoding);
action = g_object_new (GTK_TYPE_RADIO_ACTION,
"name", name,
"label", _(info->title),
"tooltip", tooltip,
NULL);
gtk_radio_action_set_group (GTK_RADIO_ACTION (action),
menu->priv->encodings_radio_group);
menu->priv->encodings_radio_group = gtk_radio_action_get_group
(GTK_RADIO_ACTION (action));
g_signal_connect (action, "activate",
G_CALLBACK (encoding_activate_cb),
menu);
gtk_action_group_add_action (menu->priv->action_group, action);
g_object_unref (action);
g_free (tooltip);
return action;
}
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 );
}
}
void
nautilus_menus_append_bookmark_to_menu (NautilusWindow *window,
NautilusBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
NautilusBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
char *name;
GdkPixbuf *pixbuf;
GtkAction *action;
g_assert (NAUTILUS_IS_WINDOW (window));
g_assert (NAUTILUS_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = nautilus_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
pixbuf = nautilus_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);
g_object_unref (pixbuf);
g_free (name);
}
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
plug_in_actions_build_path (GimpActionGroup *group,
const gchar *path_original,
const gchar *path_translated)
{
GHashTable *path_table;
gchar *copy_original;
gchar *copy_translated;
gchar *p1, *p2;
path_table = g_object_get_data (G_OBJECT (group), "plug-in-path-table");
if (! path_table)
{
path_table = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
g_object_set_data_full (G_OBJECT (group), "plug-in-path-table",
path_table,
(GDestroyNotify) g_hash_table_destroy);
}
copy_original = gimp_strip_uline (path_original);
copy_translated = g_strdup (path_translated);
p1 = strrchr (copy_original, '/');
p2 = strrchr (copy_translated, '/');
if (p1 && p2 && ! g_hash_table_lookup (path_table, copy_original))
{
GtkAction *action;
gchar *label;
label = p2 + 1;
#if 0
g_print ("adding plug-in submenu '%s' (%s)\n",
copy_original, label);
#endif
action = gtk_action_new (copy_original, label, NULL, NULL);
gtk_action_group_add_action (GTK_ACTION_GROUP (group), action);
g_object_unref (action);
g_hash_table_insert (path_table, g_strdup (copy_original), action);
*p1 = '\0';
*p2 = '\0';
/* recursively call ourselves with the last part of the path removed */
plug_in_actions_build_path (group, copy_original, copy_translated);
}
g_free (copy_original);
g_free (copy_translated);
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(window), menubar);
GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup");
GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action);
GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action));
gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile);
GtkWidget *menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu);
GtkToggleAction *toggleaction;
toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemNew);
toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemOpen);
toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemSave);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
gboolean
calendar_actions_init (GtkUIManager *ui_manager, EShellView *shell_view)
{
EShellWindow *shell_window;
GtkActionGroup *action_group;
GtkAction *action;
shell_window = e_shell_view_get_shell_window (shell_view);
action_group = e_shell_window_get_action_group (shell_window, "calendar");
/* action = gtk_action_new ("calendar-permissions", _("Setup permissions"), _("Setup 3e calendar permissions"), "stock_shared-by-me");
gtk_action_group_add_action (action_group, action);
g_signal_connect (
action, "activate",
G_CALLBACK (on_permissions_cb), shell_view);
g_object_unref (action);*/
action = gtk_action_new ("calendar-unsubscribe", _("Unsubscribe"), _("Unsubscribe a previously subscribed 3e calendar"), "remove");
gtk_action_group_add_action (action_group, action);
g_signal_connect (
action, "activate",
G_CALLBACK (on_unsubscribe_cb), shell_view);
g_object_unref (action);
action = gtk_action_new ("calendar-delete-3e", _("Delete from server"), _("Delete calendar from 3e server"), GTK_STOCK_DELETE);
gtk_action_group_add_action (action_group, action);
g_signal_connect (
action, "activate",
G_CALLBACK (on_delete_cb), shell_view);
g_object_unref (action);
return TRUE;
}
void
ppg_action_factory_create (PpgActionFactory *factory,
GtkWidget *widget,
GtkActionGroup *action_group)
{
GtkAction *action;
g_return_if_fail(factory != NULL);
g_return_if_fail(factory->action_type ||
factory->action_func ||
factory->action_entries ||
factory->toggle_action_entries);
g_return_if_fail(GTK_IS_WIDGET(widget));
g_return_if_fail(GTK_IS_ACTION_GROUP(action_group));
if (factory->action_type) {
action = g_object_new(factory->action_type, NULL);
gtk_action_group_add_action(action_group, action);
g_object_unref(action);
} else if (factory->action_func) {
action = factory->action_func(widget);
gtk_action_group_add_action(action_group, action);
g_object_unref(action);
} else if (factory->action_entries) {
gtk_action_group_add_actions(action_group,
factory->action_entries,
factory->action_n_entries,
widget);
} else if (factory->toggle_action_entries) {
gtk_action_group_add_toggle_actions(action_group,
factory->toggle_action_entries,
factory->action_n_entries,
widget);
} else {
g_assert_not_reached();
}
}
static void
empathy_mic_menu_constructed (GObject *obj)
{
EmpathyMicMenu *self = EMPATHY_MIC_MENU (obj);
EmpathyMicMenuPrivate *priv = self->priv;
GtkUIManager *ui_manager;
EmpathyGstAudioSrc *audio;
g_assert (EMPATHY_IS_CALL_WINDOW (priv->window));
ui_manager = empathy_call_window_get_ui_manager (priv->window);
audio = empathy_call_window_get_audio_src (priv->window);
g_assert (GTK_IS_UI_MANAGER (ui_manager));
g_assert (EMPATHY_IS_GST_AUDIO_SRC (audio));
/* Okay let's go go go. */
priv->mic_monitor = empathy_mic_monitor_new ();
priv->action_group = gtk_action_group_new ("EmpathyMicMenu");
gtk_ui_manager_insert_action_group (ui_manager, priv->action_group, -1);
/* the UI manager now owns this */
g_object_unref (priv->action_group);
priv->anchor_action = g_object_new (GTK_TYPE_RADIO_ACTION,
"name", "EmpathyMicMenuAnchorAction",
NULL);
gtk_action_group_add_action (priv->action_group, priv->anchor_action);
g_object_unref (priv->anchor_action);
priv->microphones = g_queue_new ();
/* Don't bother with any of this if we don't support changing
* microphone, so don't listen for microphone changes or enumerate
* the available microphones. */
if (!empathy_audio_src_supports_changing_mic (audio))
return;
tp_g_signal_connect_object (audio, "notify::microphone",
G_CALLBACK (empathy_mic_menu_notify_microphone_cb), self, 0);
tp_g_signal_connect_object (priv->mic_monitor, "microphone-added",
G_CALLBACK (empathy_mic_menu_microphone_added_cb), self, 0);
tp_g_signal_connect_object (priv->mic_monitor, "microphone-removed",
G_CALLBACK (empathy_mic_menu_microphone_removed_cb), self, 0);
empathy_mic_monitor_list_microphones_async (priv->mic_monitor,
empathy_mic_menu_list_microphones_cb, self);
}
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
create_actions (GdmPasswordExtension *extension)
{
GtkAction *action;
extension->priv->actions = gtk_action_group_new (GDM_PASSWORD_EXTENSION_NAME);
action = gtk_action_new (GDM_LOGIN_EXTENSION_DEFAULT_ACTION,
_("Log In"), NULL, NULL);
g_signal_connect_swapped (action, "activate",
G_CALLBACK (on_activate_log_in), extension);
g_object_set (G_OBJECT (action), "icon-name", "go-home", NULL);
gtk_action_group_add_action (extension->priv->actions,
action);
extension->priv->login_action = action;
}
int
clip_GTK_ACTIONGROUPADDACTION(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
C_object *caction = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(caction, GTK_IS_ACTION(caction->object));
gtk_action_group_add_action(GTK_ACTION_GROUP(cagroup->object), GTK_ACTION(caction->object));
return 0;
err:
return 1;
}
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 );
}
void
export_tools__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GtkAction *action;
GError *error = NULL;
guint merge_id;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->browser = browser;
data->action_group = gtk_action_group_new ("Export Tools Actions");
gtk_action_group_set_translation_domain (data->action_group, NULL);
/* tools menu action */
action = g_object_new (GTH_TYPE_TOGGLE_MENU_ACTION,
"name", "ExportTools",
"icon-name", "share",
"label", _("Share"),
/*"tooltip", _("Export files"),*/
"is-important", TRUE,
NULL);
gth_toggle_menu_action_set_show_menu_func (GTH_TOGGLE_MENU_ACTION (action),
export_tools_show_menu_func,
data,
NULL);
gtk_action_group_add_action (data->action_group, action);
g_object_unref (action);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->action_group, 0);
merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), ui_info, -1, &error);
if (merge_id == 0) {
g_warning ("building ui failed: %s", error->message);
g_clear_error (&error);
}
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
static GtkAction *
add_menu_item (const char *address,
const char *suffix,
const char *label,
GtkUIManager *uimanager,
guint merge_id,
GCallback callback)
{
GtkAction *action;
char *action_path, *action_name;
g_return_val_if_fail (address != NULL, NULL);
g_return_val_if_fail (suffix != NULL, NULL);
g_return_val_if_fail (label != NULL, NULL);
action_name = g_strdup_printf ("%s-%s", address, suffix);
action = gtk_action_new (action_name, label, NULL, NULL);
gtk_action_group_add_action (devices_action_group, action);
g_object_unref (action);
action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", address);
gtk_ui_manager_add_ui (uimanager, merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM, FALSE);
g_free (action_path);
g_free (action_name);
if (callback != NULL)
g_signal_connect (G_OBJECT (action), "activate", callback, NULL);
g_object_set_data_full (G_OBJECT (action),
"address", g_strdup (address), g_free);
return action;
}
static guint
ensure_menu_path (GtkUIManager *ui_manager, GtkActionGroup *actions, const gchar *path, gboolean end)
{
guint id = gtk_ui_manager_new_merge_id (ui_manager);
if (!gtk_ui_manager_get_widget (ui_manager, path)) {
gchar *subpath = g_strdup (path);
if (strrchr (subpath, '/')) {
const gchar *action_name;
gchar *sep;
GtkAction *action;
sep = strrchr (subpath, '/');
*sep = '\0'; /* cut subpath */
action_name = sep + 1;
ensure_menu_path (ui_manager, actions, subpath, FALSE);
action = gtk_action_new (action_name, sep + 1, NULL, NULL);
if (!gtk_action_group_get_action (actions, action_name))
gtk_action_group_add_action (actions, action);
g_object_unref (G_OBJECT (action));
gtk_ui_manager_add_ui (ui_manager, id, subpath,
action_name, action_name,
end ? GTK_UI_MANAGER_SEPARATOR : GTK_UI_MANAGER_MENU,
FALSE); /* FALSE=add-to-end */
} else {
g_warning ("ensure_menu_path() invalid menu path: %s.", subpath ? subpath : "NULL");
}
g_free (subpath);
}
return id;
}
static void
update_device_list (BluetoothApplet *applet,
gpointer user_data)
{
GtkUIManager *uimanager;
GList *actions, *devices, *l;
gboolean has_devices = FALSE;
uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager"));
devices = bluetooth_applet_get_devices (applet);
if (devices == NULL) {
/* No devices? 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);
for (l = devices; l != NULL; l = g_list_next (l)) {
BluetoothSimpleDevice *device = l->data;
GtkAction *action, *status, *oper;
char *name;
if (device_has_submenu (device) == FALSE) {
g_boxed_free (BLUETOOTH_TYPE_SIMPLE_DEVICE, device);
continue;
}
has_devices = TRUE;
action = gtk_action_group_get_action (devices_action_group, device->bdaddr);
oper = NULL;
status = NULL;
if (action) {
char *action_name;
actions = g_list_remove (actions, action);
action_name = g_strdup_printf ("%s-status", device->bdaddr);
status = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
action_name = g_strdup_printf ("%s-action", device->bdaddr);
oper = gtk_action_group_get_action (devices_action_group, action_name);
g_free (action_name);
}
name = escape_label_for_action (device->alias);
if (action == NULL) {
guint menu_merge_id;
char *action_path;
/* The menu item with descendants */
action = gtk_action_new (device->bdaddr, 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", device->bdaddr, device->bdaddr,
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 (device->bdaddr,
"status",
device->connected ? _("Connected") : _("Disconnected"),
uimanager,
menu_merge_id,
NULL);
gtk_action_set_sensitive (status, FALSE);
if (device->can_connect) {
action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status",
device->bdaddr, device->bdaddr);
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 (device->bdaddr,
"action",
device->connected ? _("Disconnect") : _("Connect"),
uimanager,
menu_merge_id,
G_CALLBACK (on_connect_activate));
if (!device->can_connect)
gtk_action_set_visible (oper, FALSE);
add_separator_item (device->bdaddr, "connect-sep", uimanager, menu_merge_id);
/* The Send to... button */
if (device->capabilities & BLUETOOTH_CAPABILITIES_OBEX_PUSH) {
add_menu_item (device->bdaddr,
"sendto",
_("Send files..."),
uimanager,
menu_merge_id,
G_CALLBACK (sendto_callback));
g_object_set_data_full (G_OBJECT (action),
"alias", g_strdup (device->alias), g_free);
}
if (device->capabilities & BLUETOOTH_CAPABILITIES_OBEX_FILE_TRANSFER) {
add_menu_item (device->bdaddr,
"browse",
_("Browse files..."),
uimanager,
menu_merge_id,
G_CALLBACK (browse_callback));
}
add_separator_item (device->bdaddr, "files-sep", uimanager, menu_merge_id);
if (device->type == BLUETOOTH_TYPE_KEYBOARD && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"keyboard",
_("Keyboard Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (keyboard_callback));
}
if (device->type == BLUETOOTH_TYPE_MOUSE && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"mouse",
_("Mouse and Touchpad Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (mouse_callback));
}
if ((device->type == BLUETOOTH_TYPE_HEADSET ||
device->type == BLUETOOTH_TYPE_HEADPHONES ||
device->type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (GNOMECC)) {
add_menu_item (device->bdaddr,
"sound",
_("Sound Settings"),
uimanager,
menu_merge_id,
G_CALLBACK (sound_callback));
}
} else {
gtk_action_set_label (action, name);
if (device->can_connect) {
gtk_action_set_visible (status, TRUE);
gtk_action_set_visible (oper, TRUE);
set_device_status_label (device->bdaddr, device->connected ? CONNECTED : DISCONNECTED);
gtk_action_set_label (oper, device->connected ? _("Disconnect") : _("Connect"));
} else {
gtk_action_set_visible (status, FALSE);
gtk_action_set_visible (oper, FALSE);
}
}
g_free (name);
if (oper != NULL) {
g_object_set_data_full (G_OBJECT (oper),
"connected", GINT_TO_POINTER (device->connected ? CONNECTED : DISCONNECTED), NULL);
g_object_set_data_full (G_OBJECT (oper),
"device-path", g_strdup (device->device_path), g_free);
}
/* And now for the trick of the day */
if (device->connected != FALSE) {
char *path;
path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", device->bdaddr);
action_set_bold (uimanager, action, path);
g_free (path);
}
g_boxed_free (BLUETOOTH_TYPE_SIMPLE_DEVICE, device);
}
/* Remove the left-over devices */
g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
g_list_free (actions);
/* Cleanup */
g_list_free (devices);
done:
gtk_ui_manager_ensure_update (uimanager);
gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
has_devices);
}
void
athena_menus_append_bookmark_to_menu (AthenaWindow *window,
AthenaBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
AthenaBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
const char *name;
char *path;
GIcon *icon;
GtkAction *action;
GtkWidget *menuitem;
g_assert (ATHENA_IS_WINDOW (window));
g_assert (ATHENA_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = athena_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
icon = athena_bookmark_get_icon (bookmark);
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",
icon,
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_free (path);
}
static GtkUIManager *
ui_manager_new (GtkWidget *window)
{
static const GtkActionEntry actions[] =
{
{
"back", GTK_STOCK_GO_BACK,
NULL, "<alt>Left", N_("Go back one page"),
G_CALLBACK (back_callback)
},
{
"forward", GTK_STOCK_GO_FORWARD,
NULL, "<alt>Right", N_("Go forward one page"),
G_CALLBACK (forward_callback)
},
{
"reload", GTK_STOCK_REFRESH,
N_("_Reload"), "<control>R", N_("Reload current page"),
G_CALLBACK (reload_callback)
},
{
"stop", GTK_STOCK_CANCEL,
N_("_Stop"), "Escape", N_("Stop loading this page"),
G_CALLBACK (stop_callback)
},
{
"home", GTK_STOCK_HOME,
NULL, "<alt>Home", N_("Go to the index page"),
G_CALLBACK (home_callback)
},
{
"copy-location", GTK_STOCK_COPY,
N_("C_opy location"), "",
N_("Copy the location of this page to the clipboard"),
G_CALLBACK (copy_location_callback)
},
{
"copy-selection", GTK_STOCK_COPY,
NULL, "<control>C", NULL,
G_CALLBACK (copy_selection_callback)
},
{
"zoom-in", GTK_STOCK_ZOOM_IN,
NULL, "<control>plus", NULL,
G_CALLBACK (zoom_in_callback)
},
{
"zoom-out", GTK_STOCK_ZOOM_OUT,
NULL, "<control>minus", NULL,
G_CALLBACK (zoom_out_callback)
},
{
"find", GTK_STOCK_FIND,
NULL, "<control>F", N_("Find text in current page"),
G_CALLBACK (find_callback)
},
{
"find-again", NULL,
N_("Find _Again"), "<control>G", NULL,
G_CALLBACK (find_again_callback)
},
{
"close", GTK_STOCK_CLOSE,
NULL, "<control>W", NULL,
G_CALLBACK (close_callback)
},
{
"quit", GTK_STOCK_QUIT,
NULL, "<control>Q", NULL,
G_CALLBACK (close_callback)
}
};
static const GtkToggleActionEntry toggle_actions[] =
{
{
"show-index", NULL,
N_("S_how Index"), "<control>I",
N_("Toggle the visibility of the sidebar"),
G_CALLBACK (show_index_callback), FALSE
}
};
GtkUIManager *ui_manager = gtk_ui_manager_new ();
GtkActionGroup *group = gtk_action_group_new ("Actions");
GtkAction *action;
GError *error = NULL;
gtk_action_group_set_translation_domain (group, NULL);
gtk_action_group_add_actions (group,
actions, G_N_ELEMENTS (actions),
NULL);
gtk_action_group_add_toggle_actions (group,
toggle_actions,
G_N_ELEMENTS (toggle_actions),
NULL);
action = gimp_throbber_action_new ("website",
"docs.gimp.org",
_("Visit the GIMP documentation website"),
GIMP_STOCK_USER_MANUAL);
g_signal_connect_closure (action, "activate",
g_cclosure_new (G_CALLBACK (website_callback),
NULL, NULL),
FALSE);
gtk_action_group_add_action (group, action);
g_object_unref (action);
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
gtk_ui_manager_insert_action_group (ui_manager, group, -1);
g_object_unref (group);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <toolbar name=\"help-browser-toolbar\">"
" <toolitem action=\"reload\" />"
" <toolitem action=\"stop\" />"
" <toolitem action=\"home\" />"
" <separator name=\"space\" />"
" <toolitem action=\"website\" />"
" </toolbar>"
" <accelerator action=\"close\" />"
" <accelerator action=\"quit\" />"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <popup name=\"help-browser-popup\">"
" <menuitem action=\"back\" />"
" <menuitem action=\"forward\" />"
" <menuitem action=\"reload\" />"
" <menuitem action=\"stop\" />"
" <separator />"
" <menuitem action=\"home\" />"
" <menuitem action=\"copy-location\" />"
" <menuitem action=\"show-index\" />"
" <separator />"
" <menuitem action=\"find\" />"
" <menuitem action=\"find-again\" />"
" <separator />"
" <menuitem action=\"zoom-in\" />"
" <menuitem action=\"zoom-out\" />"
" <separator />"
" <menuitem action=\"close\" />"
" </popup>"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <popup name=\"help-browser-copy-popup\">"
" <menuitem action=\"copy-selection\" />"
" </popup>"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
return ui_manager;
}
static void
editor_inline_spelling_suggestions (GtkhtmlEditor *editor,
GtkhtmlSpellChecker *checker)
{
GtkActionGroup *action_group;
GtkUIManager *manager;
GtkHTML *html;
GList *list;
const gchar *path;
gchar *word;
guint count = 0;
guint length;
guint merge_id;
guint threshold;
html = gtkhtml_editor_get_html (editor);
word = html_engine_get_spell_word (html->engine);
list = gtkhtml_spell_checker_get_suggestions (checker, word, -1);
path = "/context-menu/context-spell-suggest/";
manager = gtkhtml_editor_get_ui_manager (editor);
action_group = editor->priv->suggestion_actions;
merge_id = editor->priv->spell_suggestions_merge_id;
/* Calculate how many suggestions to put directly in the
* context menu. The rest will go in a secondary menu. */
length = g_list_length (list);
if (length <= MAX_LEVEL1_SUGGESTIONS)
threshold = length;
else if (length - MAX_LEVEL1_SUGGESTIONS < MIN_LEVEL2_SUGGESTIONS)
threshold = length;
else
threshold = MAX_LEVEL1_SUGGESTIONS;
while (list != NULL) {
gchar *suggestion = list->data;
gchar *action_name;
gchar *action_label;
GtkAction *action;
GtkWidget *child;
GSList *proxies;
/* Once we reach the threshold, put all subsequent
* spelling suggestions in a secondary menu. */
if (count == threshold)
path = "/context-menu/context-more-suggestions-menu/";
/* Action name just needs to be unique. */
action_name = g_strdup_printf ("suggest-%d", count++);
action_label = g_markup_printf_escaped (
"<b>%s</b>", suggestion);
action = gtk_action_new (
action_name, action_label, NULL, NULL);
g_object_set_data_full (
G_OBJECT (action), "word",
g_strdup (suggestion), g_free);
g_signal_connect (
action, "activate", G_CALLBACK (
action_context_spell_suggest_cb), editor);
gtk_action_group_add_action (action_group, action);
gtk_ui_manager_add_ui (
manager, merge_id, path,
action_name, action_name,
GTK_UI_MANAGER_AUTO, FALSE);
/* XXX GtkAction offers no support for Pango markup,
* so we have to manually set "use-markup" on the
* child of the proxy widget. */
gtk_ui_manager_ensure_update (manager);
proxies = gtk_action_get_proxies (action);
child = gtk_bin_get_child (proxies->data);
g_object_set (child, "use-markup", TRUE, NULL);
g_free (suggestion);
g_free (action_name);
g_free (action_label);
list = g_list_delete_link (list, list);
}
g_free (word);
}
static void
toolbar_visibility_refresh (EggEditableToolbar *etoolbar)
{
EggEditableToolbarPrivate *priv = etoolbar->priv;
gint n_toolbars, n_items, i, j, k;
GtkToggleAction *action;
GList *list;
GString *string;
gboolean showing;
char action_name[40];
char *action_label;
char *tmp;
if (priv == NULL || priv->model == NULL || priv->manager == NULL ||
priv->visibility_paths == NULL || priv->actions == NULL)
{
return;
}
if (priv->visibility_actions == NULL)
{
priv->visibility_actions = g_ptr_array_new ();
}
if (priv->visibility_id != 0)
{
gtk_ui_manager_remove_ui (priv->manager, priv->visibility_id);
}
priv->visibility_id = gtk_ui_manager_new_merge_id (priv->manager);
showing = gtk_widget_get_visible (GTK_WIDGET (etoolbar));
n_toolbars = egg_toolbars_model_n_toolbars (priv->model);
for (i = 0; i < n_toolbars; i++)
{
string = g_string_sized_new (0);
n_items = egg_toolbars_model_n_items (priv->model, i);
for (k = 0, j = 0; j < n_items; j++)
{
GValue value = { 0, };
GtkAction *action;
const char *name;
name = egg_toolbars_model_item_nth (priv->model, i, j);
if (name == NULL) continue;
action = find_action (etoolbar, name);
if (action == NULL) continue;
g_value_init (&value, G_TYPE_STRING);
g_object_get_property (G_OBJECT (action), "label", &value);
name = g_value_get_string (&value);
if (name == NULL)
{
g_value_unset (&value);
continue;
}
k += g_utf8_strlen (name, -1) + 2;
if (j > 0)
{
g_string_append (string, ", ");
if (j > 1 && k > 25)
{
g_value_unset (&value);
break;
}
}
g_string_append (string, name);
g_value_unset (&value);
}
if (j < n_items)
{
g_string_append (string, " ...");
}
tmp = g_string_free (string, FALSE);
for (j = 0, k = 0; tmp[j]; j++)
{
if (tmp[j] == '_') continue;
tmp[k] = tmp[j];
k++;
}
tmp[k] = 0;
/* Translaters: This string is for a toggle to display a toolbar.
* The name of the toolbar is automatically computed from the widgets
* on the toolbar, and is placed at the %s. Note the _ before the %s
* which is used to add mnemonics. We know that this is likely to
* produce duplicates, but don't worry about it. If your language
* normally has a mnemonic at the start, please use the _. If not,
* please remove. */
action_label = g_strdup_printf (_("Show “_%s”"), tmp);
g_free (tmp);
sprintf(action_name, "ToolbarToggle%d", i);
if (i >= priv->visibility_actions->len)
{
action = gtk_toggle_action_new (action_name, action_label, NULL, NULL);
g_ptr_array_add (priv->visibility_actions, action);
g_signal_connect_object (action, "toggled",
G_CALLBACK (toggled_visibility_cb),
etoolbar, 0);
gtk_action_group_add_action (priv->actions, GTK_ACTION (action));
}
else
{
action = g_ptr_array_index (priv->visibility_actions, i);
g_object_set (action, "label", action_label, NULL);
}
gtk_action_set_visible (GTK_ACTION (action), (egg_toolbars_model_get_flags (priv->model, i)
& EGG_TB_MODEL_NOT_REMOVABLE) == 0);
gtk_action_set_sensitive (GTK_ACTION (action), showing);
gtk_toggle_action_set_active (action, gtk_widget_get_visible
(get_dock_nth (etoolbar, i)));
for (list = priv->visibility_paths; list != NULL; list = g_list_next (list))
{
gtk_ui_manager_add_ui (priv->manager, priv->visibility_id,
(const char *)list->data, action_name, action_name,
GTK_UI_MANAGER_MENUITEM, FALSE);
}
g_free (action_label);
}
gtk_ui_manager_ensure_update (priv->manager);
while (i < priv->visibility_actions->len)
{
action = g_ptr_array_index (priv->visibility_actions, i);
g_ptr_array_remove_index_fast (priv->visibility_actions, i);
gtk_action_group_remove_action (priv->actions, GTK_ACTION (action));
i++;
}
}
/* initialize callbacks from plug-ins */
static void
add_plugin_actions (GtkUIManager *ui_manager, const gchar *base_path)
{
GtkActionGroup *actions;
GtkAction *action;
GList *cblist;
DiaCallbackFilter *cbf = NULL;
gchar *name;
guint id;
static guint cnt = 0;
name = g_strdup_printf ("plugin-actions-%d", cnt);
actions = gtk_action_group_new (name);
gtk_action_group_set_translation_domain (actions, NULL);
gtk_action_group_set_translate_func (actions, _dia_translate, NULL, NULL);
g_free (name);
name = NULL;
cnt++;
gtk_ui_manager_insert_action_group (ui_manager, actions, 5 /* "back" */);
g_object_unref (actions);
for (cblist = filter_get_callbacks(); cblist; cblist = cblist->next) {
gchar *menu_path = NULL;
cbf = cblist->data;
if (cbf == NULL) {
g_warning ("missing DiaCallbackFilter instance");
continue;
}
if (cbf->action == NULL) {
g_warning ("Plugin '%s': doesn't specify action. Loading failed.",
cbf->description);
continue;
}
if ( base_path != NULL
&& strncmp (cbf->menupath, base_path, strlen (base_path)) != 0) {
/* hook for wrong base path, skip */
continue;
} else if (!base_path) {
/* only replace what we know */
if (strncmp (cbf->menupath, DISPLAY_MENU, strlen (DISPLAY_MENU)) == 0)
menu_path = g_strdup_printf ("%s%s", INTEGRATED_MENU, cbf->menupath + strlen (DISPLAY_MENU));
else if (strncmp (cbf->menupath, TOOLBOX_MENU, strlen (TOOLBOX_MENU)) == 0)
menu_path = g_strdup_printf ("%s%s", INTEGRATED_MENU, cbf->menupath + strlen (TOOLBOX_MENU));
}
action = gtk_action_new (cbf->action, cbf->description, NULL, NULL);
g_signal_connect (G_OBJECT (action), "activate",
G_CALLBACK (plugin_callback), (gpointer) cbf);
gtk_action_group_add_action (actions, action);
g_object_unref (G_OBJECT (action));
id = ensure_menu_path (ui_manager, actions, menu_path ? menu_path : cbf->menupath, TRUE);
gtk_ui_manager_add_ui (ui_manager, id,
menu_path ? menu_path : cbf->menupath,
cbf->description,
cbf->action,
GTK_UI_MANAGER_AUTO,
FALSE);
g_free (menu_path);
}
}
/* Helper for gtkhtml_editor_update_context() */
static void
editor_spell_checkers_foreach (GtkhtmlSpellChecker *checker,
GtkhtmlEditor *editor)
{
const GtkhtmlSpellLanguage *language;
const gchar *language_code;
GtkActionGroup *action_group;
GtkUIManager *manager;
GtkHTML *html;
GList *list;
gchar *path;
gchar *word;
gint count = 0;
guint merge_id;
language = gtkhtml_spell_checker_get_language (checker);
language_code = gtkhtml_spell_language_get_code (language);
html = gtkhtml_editor_get_html (editor);
word = html_engine_get_spell_word (html->engine);
list = gtkhtml_spell_checker_get_suggestions (checker, word, -1);
manager = gtkhtml_editor_get_ui_manager (editor);
action_group = editor->priv->suggestion_actions;
merge_id = editor->priv->spell_suggestions_merge_id;
path = g_strdup_printf (
"/context-menu/context-spell-suggest/"
"context-spell-suggest-%s-menu", language_code);
while (list != NULL) {
gchar *suggestion = list->data;
gchar *action_name;
gchar *action_label;
GtkAction *action;
GtkWidget *child;
GSList *proxies;
/* Action name just needs to be unique. */
action_name = g_strdup_printf (
"suggest-%s-%d", language_code, count++);
action_label = g_markup_printf_escaped (
"<b>%s</b>", suggestion);
action = gtk_action_new (
action_name, action_label, NULL, NULL);
g_object_set_data_full (
G_OBJECT (action), "word",
g_strdup (suggestion), g_free);
g_signal_connect (
action, "activate", G_CALLBACK (
action_context_spell_suggest_cb), editor);
gtk_action_group_add_action (action_group, action);
gtk_ui_manager_add_ui (
manager, merge_id, path,
action_name, action_name,
GTK_UI_MANAGER_AUTO, FALSE);
/* XXX GtkAction offers no supports for Pango markup,
* so we have to manually set "use-markup" on the
* child of the proxy widget. */
gtk_ui_manager_ensure_update (manager);
proxies = gtk_action_get_proxies (action);
child = gtk_bin_get_child (proxies->data);
g_object_set (child, "use-markup", TRUE, NULL);
g_free (suggestion);
g_free (action_name);
g_free (action_label);
list = g_list_delete_link (list, list);
}
g_free (path);
g_free (word);
}
