void
edit_metadata__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->browser = browser;
data->actions = gtk_action_group_new ("Edit Metadata Actions");
gtk_action_group_set_translation_domain (data->actions, NULL);
_gtk_action_group_add_actions_with_flags (data->actions,
edit_metadata_action_entries,
G_N_ELEMENTS (edit_metadata_action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->actions, 0);
if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
if (gth_main_extension_is_active ("list_tools") && ! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_file_tools_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
static void
file_manager_update_ui (BrowserData *data,
GthBrowser *browser)
{
if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))) {
if (data->vfs_merge_id == 0) {
GError *local_error = NULL;
data->vfs_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), vfs_ui_info, -1, &local_error);
if (data->vfs_merge_id == 0) {
g_warning ("building ui failed: %s", local_error->message);
g_error_free (local_error);
}
}
}
else if (data->vfs_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->vfs_merge_id);
data->vfs_merge_id = 0;
}
if (gth_window_get_current_page (GTH_WINDOW (browser)) == GTH_BROWSER_PAGE_BROWSER) {
if (data->browser_merge_id == 0) {
GError *local_error = NULL;
data->browser_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), browser_ui_info, -1, &local_error);
if (data->browser_merge_id == 0) {
g_warning ("building ui failed: %s", local_error->message);
g_error_free (local_error);
}
}
}
else if (data->browser_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->browser_merge_id);
data->browser_merge_id = 0;
}
if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))
&& (gth_window_get_current_page (GTH_WINDOW (browser)) == GTH_BROWSER_PAGE_BROWSER))
{
if (data->browser_vfs_merge_id == 0) {
GError *local_error = NULL;
data->browser_vfs_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), browser_vfs_ui_info, -1, &local_error);
if (data->browser_vfs_merge_id == 0) {
g_warning ("building ui failed: %s", local_error->message);
g_error_free (local_error);
}
}
}
else if (data->browser_vfs_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->browser_vfs_merge_id);
data->browser_vfs_merge_id = 0;
}
}
static void
install_menu (PlumaWindow *window)
{
GtkUIManager *manager;
WindowData *data = BOOKMARKS_DATA (window);
GError *error = NULL;
manager = pluma_window_get_ui_manager (window);
data->action_group = gtk_action_group_new ("PlumaBookmarksPluginActions");
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);
gtk_ui_manager_insert_action_group (manager, data->action_group, -1);
data->ui_id = gtk_ui_manager_add_ui_from_string (manager, uidefinition, -1, &error);
if (!data->ui_id)
{
g_warning ("Could not load UI: %s", error->message);
g_error_free (error);
}
}
void
db__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->action_group = gtk_action_group_new ("Desktop Background Actions");
gtk_action_group_set_translation_domain (data->action_group, NULL);
gtk_action_group_add_actions (data->action_group,
action_entries,
G_N_ELEMENTS (action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->action_group, 0);
if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_clear_error (&error);
}
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/FileListPopup/Screen_Actions/DesktopBackground")), TRUE);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/FilePopup/Screen_Actions/DesktopBackground")), TRUE);
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
/* create the popup menu */
static void
_dtv_create_popup_menu (DiagramTreeView *dtv)
{
static GtkActionEntry menu_items [] = {
{ "Select", NULL, N_("Select"), NULL, NULL, G_CALLBACK (_dtv_select_items) },
{ "Locate", NULL, N_("Locate"), NULL, NULL, G_CALLBACK (_dtv_locate_item) },
{ "Properties", NULL, N_("Properties"), NULL, NULL, G_CALLBACK(_dtv_showprops_item) }
};
static const gchar *ui_description =
"<ui>"
" <popup name='PopupMenu'>"
" <menuitem action='Select'/>"
" <menuitem action='Locate'/>"
" <menuitem action='Properties'/>"
" </popup>"
"</ui>";
GtkActionGroup *action_group;
g_return_if_fail (dtv->popup == NULL && dtv->ui_manager == NULL);
action_group = gtk_action_group_new ("PopupActions");
gtk_action_group_set_translation_domain (action_group, NULL); /* FIXME? */
gtk_action_group_add_actions (action_group, menu_items,
G_N_ELEMENTS (menu_items), dtv);
dtv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (dtv->ui_manager, action_group, 0);
if (gtk_ui_manager_add_ui_from_string (dtv->ui_manager, ui_description, -1, NULL))
dtv->popup = GTK_MENU(gtk_ui_manager_get_widget (dtv->ui_manager, "/ui/PopupMenu"));
}
static GtkUIManager *
create_ui_manager (MduShell *shell)
{
GtkUIManager *ui_manager;
GError *error;
shell->priv->action_group = gtk_action_group_new ("MateDiskUtilityActions");
gtk_action_group_set_translation_domain (shell->priv->action_group, NULL);
gtk_action_group_add_actions (shell->priv->action_group, entries, G_N_ELEMENTS (entries), shell);
/* -------------------------------------------------------------------------------- */
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->action_group, 0);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string
(ui_manager, ui, -1, &error)) {
g_message ("Building menus failed: %s", error->message);
g_error_free (error);
gtk_main_quit ();
}
return ui_manager;
}
static void
create_game_menus (GtkUIManager * ui_manager)
{
GtkActionGroup *action_group;
games_stock_init ();
action_group = gtk_action_group_new ("actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group, action_entry,
G_N_ELEMENTS (action_entry), app);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL);
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (ui_manager));
new_game_action = gtk_action_group_get_action (action_group, "NewGame");
hint_action = gtk_action_group_get_action (action_group, "Hint");
undo_action = gtk_action_group_get_action (action_group, "UndoMove");
fullscreen_action = GTK_ACTION (games_fullscreen_action_new ("Fullscreen", GTK_WINDOW (app)));
gtk_action_group_add_action_with_accel (action_group, fullscreen_action, NULL);
}
static void
about_initgui(Tbfwin * bfwin)
{
GtkActionGroup *action_group;
GError *error = NULL;
static const GtkActionEntry about_actions[] = {
{"HelpMenu", NULL, N_("_Help")},
{"HelpHomepage", GTK_STOCK_HOME, N_("Bluefish _Homepage"), NULL, N_("Bluefish homepage"),
G_CALLBACK(about_show_homepage)},
{"HelpReportBug", NULL, N_("Report a _Bug"), NULL, N_("Report a bug"), G_CALLBACK(about_report_bug)},
{"HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL, N_("About Bluefish"),
G_CALLBACK(about_dialog_create)},
{"HelpBuildInfo", GTK_STOCK_INFO, N_("Build _Info"), NULL, N_("Build info"),
G_CALLBACK(about_options_dialog_create)}
};
action_group = gtk_action_group_new("AboutActions");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE "_plugin_about");
gtk_action_group_add_actions(action_group, about_actions, G_N_ELEMENTS(about_actions), bfwin);
gtk_ui_manager_insert_action_group(bfwin->uimanager, action_group, 0);
g_object_unref(action_group);
gtk_ui_manager_add_ui_from_string(bfwin->uimanager, about_plugin_ui, -1, &error);
if (error != NULL) {
g_warning("building about plugin menu failed: %s", error->message);
g_error_free(error);
}
}
GtkWidget*
lyric_show_menu_get_for(LyricShow *lsw)
{
GtkUIManager *ui;
GtkActionGroup *actiongroup;
GtkWidget *menu = NULL;
g_return_if_fail(lsw != NULL && G_IS_OBJECT(lsw));
menu = g_object_get_data(lsw,"MENU");
if(menu == NULL)
{
ui = gtk_ui_manager_new();
gtk_ui_manager_add_ui_from_string(ui,ui_xml,-1,NULL);
actiongroup = gtk_action_group_new("menu");
#ifdef GETTEXT_PACKAGE
gtk_action_group_set_translation_domain(actiongroup,GETTEXT_PACKAGE);
#endif
gtk_action_group_add_actions(actiongroup,ui_menu_entry,n_ui_menu_entry,lsw);
gtk_ui_manager_insert_action_group(ui,actiongroup,-1);
g_object_unref(actiongroup);
menu = gtk_ui_manager_get_widget(ui,"/menu");
g_signal_connect_swapped(lsw,"destroy",G_CALLBACK(gtk_widget_destroy),menu);
g_object_set_data(lsw,"MENU",menu);
g_object_ref(menu);
g_object_unref(ui);
}
return menu;
}
void ui_init(GtkActionGroup **actiongroup, GtkUIManager **ui_manager)
{
GError* error = NULL;
GtkAction* action;
guint i;
/*添加界面相关信息*/
if(!gtk_ui_manager_add_ui_from_string(*ui_manager, ui_markup, -1, &error))
{
g_message("User interface couldn't be created: %s", error->message);
g_error_free(error);
}
for(i = 0; i < menu_entries_n; i++)
{
action = gtk_action_group_get_action(*actiongroup, menu_entries[i].name);
/*这里设置菜单是否可以激活*/
gtk_action_set_sensitive(action,
menu_entries[i].callback || !menu_entries[i].tooltip);
}
for(i = 0; i < toolbar_entries_n; i++)
{
action = gtk_action_group_get_action(*actiongroup,
toolbar_entries[i].name);
/*这里设置菜单是否可以激活*/
gtk_action_set_sensitive(action,
toolbar_entries[i].callback || !toolbar_entries[i].tooltip);
}
}
static void
sheet_item_init (SheetItem *item)
{
GError *error = NULL;
item->priv = g_new0 (SheetItemPriv, 1);
item->priv->selected = FALSE;
item->priv->preserve_selection = FALSE;
item->priv->data = NULL;
item->priv->ui_manager = NULL;
item->priv->action_group = NULL;
item->priv->ui_manager = gtk_ui_manager_new ();
item->priv->action_group = gtk_action_group_new ("action_group");
gtk_action_group_set_translation_domain (item->priv->action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (item->priv->action_group,
action_entries, G_N_ELEMENTS (action_entries), NULL);
gtk_ui_manager_insert_action_group (item->priv->ui_manager,
item->priv->action_group, 0);
if (!gtk_ui_manager_add_ui_from_string (item->priv->ui_manager,
sheet_item_context_menu, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
}
void
ip__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->action_group = gtk_action_group_new ("Image Print Actions");
gtk_action_group_set_translation_domain (data->action_group, NULL);
_gtk_action_group_add_actions_with_flags (data->action_group,
action_entries,
G_N_ELEMENTS (action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->action_group, 0);
data->fixed_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error);
if (data->fixed_merge_id == 0) {
g_warning ("building ui failed: %s", error->message);
g_error_free (error);
}
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
void
edit_metadata__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->browser = browser;
data->actions = gtk_action_group_new ("Edit Metadata Actions");
gtk_action_group_set_translation_domain (data->actions, NULL);
gtk_action_group_add_actions (data->actions,
edit_metadata_action_entries,
G_N_ELEMENTS (edit_metadata_action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->actions, 0);
if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/Fullscreen_ToolBar/Edit_Actions/Edit_Metadata")), TRUE);
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
int vwin_add_ui (windata_t *vwin, GtkActionEntry *entries,
gint n_entries, const gchar *ui_info)
{
GtkActionGroup *actions;
GError *err = NULL;
actions = gtk_action_group_new("MyActions");
gtk_action_group_set_translation_domain(actions, "gretl");
gtk_action_group_add_actions(actions, entries, n_entries, vwin);
vwin->ui = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(vwin->ui, actions, 0);
g_object_unref(actions);
gtk_window_add_accel_group(GTK_WINDOW(vwin->main),
gtk_ui_manager_get_accel_group(vwin->ui));
gtk_ui_manager_add_ui_from_string(vwin->ui, ui_info, -1, &err);
if (err != NULL) {
g_message("building menus failed: %s", err->message);
g_error_free(err);
}
vwin->mbar = gtk_ui_manager_get_widget(vwin->ui, "/menubar");
return 0;
}
static GtkWidget*
popup_menu_create (GtkTreeView *treeview)
{
GtkUIManager *ui_manager;
GtkActionGroup *action_group;
GtkWidget *popup;
g_return_val_if_fail (treeview != NULL, NULL);
action_group = gtk_action_group_new ("MenuActions");
gtk_action_group_set_translation_domain (action_group, NULL);
gtk_action_group_add_actions (action_group,
popup_menu_items,
G_N_ELEMENTS (popup_menu_items), treeview);
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL))
return NULL;
popup = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
return popup;
}
/**
* create_game_menus
* @ap: application pointer
*
* Description:
* Creates the menus for application @ap
*
**/
void
create_game_menus (GtkUIManager * ui_manager)
{
GtkActionGroup *action_group;
games_stock_init ();
action_group = gtk_action_group_new ("actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group, action_entry,
G_N_ELEMENTS (action_entry), app);
gtk_action_group_add_toggle_actions (action_group, toggle_action_entry,
G_N_ELEMENTS (toggle_action_entry),
app);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL);
scores_action = gtk_action_group_get_action (action_group, "Scores");
teleport_action = gtk_action_group_get_action (action_group, "Teleport");
random_action = gtk_action_group_get_action (action_group, "Random");
wait_action = gtk_action_group_get_action (action_group, "Wait");
toolbar_toggle_action =
gtk_action_group_get_action (action_group, "ShowToolbar");
fullscreen_action = GTK_ACTION (games_fullscreen_action_new ("Fullscreen", GTK_WINDOW (app)));
gtk_action_group_add_action_with_accel (action_group, fullscreen_action, NULL);
return;
}
static void
create_menus (GtkUIManager * ui_manager)
{
GtkActionGroup *action_group;
action_group = gtk_action_group_new ("MenuActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group, action_entry,
G_N_ELEMENTS (action_entry), window);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL);
new_game_action = gtk_action_group_get_action (action_group, "NewGame");
scores_action = gtk_action_group_get_action (action_group, "Scores");
end_game_action = gtk_action_group_get_action (action_group, "EndGame");
pause_action = gtk_action_group_get_action (action_group, "Pause");
resume_action = gtk_action_group_get_action (action_group, "Resume");
preferences_action = gtk_action_group_get_action (action_group,
"Preferences");
fullscreen_action = gtk_action_group_get_action (action_group,
"Fullscreen");
leave_fullscreen_action = gtk_action_group_get_action (action_group,
"LeaveFullscreen");
new_network_action = gtk_action_group_get_action (action_group,
"NewNetworkGame");
#ifndef GGZ_CLIENT
gtk_action_set_sensitive (new_network_action, FALSE);
#endif
player_list_action = gtk_action_group_get_action (action_group, "PlayerList");
}
void
fm__gth_browser_folder_tree_popup_before_cb (GthBrowser *browser,
GthFileSource *file_source,
GthFileData *folder)
{
BrowserData *data;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
if (GTH_IS_FILE_SOURCE_VFS (file_source)) {
if (data->folder_popup_merge_id == 0) {
GError *error = NULL;
data->folder_popup_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), folder_popup_ui_info, -1, &error);
if (data->folder_popup_merge_id == 0) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
}
fm__gth_browser_update_sensitivity_cb (browser);
}
else {
if (data->folder_popup_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->folder_popup_merge_id);
data->folder_popup_merge_id = 0;
}
}
}
void terminal_popup_menu(GtkWidget *widget,GdkEventButton * event, gpointer data)
{
MainWin * mw;
GtkUIManager *ui;
GtkActionGroup *actions;
GError *error = NULL;
GtkWidget * menu;
mw=(MainWin *)data;
if(event->type !=GDK_BUTTON_PRESS || event->button != 3){
g_print("left button\n");
return;
}
actions = gtk_action_group_new ("PopActions");
gtk_action_group_add_actions (actions, popentries, n_popentries, mw);
ui = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui, actions, 0);
gtk_window_add_accel_group (GTK_WINDOW (mw->window),
gtk_ui_manager_get_accel_group (ui));
if (!gtk_ui_manager_add_ui_from_string (ui, popui, -1, &error))
{
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
menu = gtk_ui_manager_get_widget (ui, "/ui/PopupMenu");
g_signal_connect (menu, "deactivate", G_CALLBACK (gtk_widget_destroy),NULL);
gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
gtk_get_current_event_time ());
}
static void
eog_reload_plugin_activate (EogWindowActivatable *activatable)
{
GtkUIManager *manager;
EogReloadPlugin *plugin = EOG_RELOAD_PLUGIN (activatable);
eog_debug (DEBUG_PLUGINS);
manager = eog_window_get_ui_manager (plugin->window);
plugin->ui_action_group = gtk_action_group_new ("EogReloadPluginActions");
gtk_action_group_set_translation_domain (plugin->ui_action_group,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (plugin->ui_action_group,
action_entries,
G_N_ELEMENTS (action_entries),
plugin->window);
gtk_ui_manager_insert_action_group (manager,
plugin->ui_action_group,
-1);
plugin->ui_id = gtk_ui_manager_add_ui_from_string (manager,
ui_definition,
-1, NULL);
g_warn_if_fail (plugin->ui_id != 0);
}
//==============================================================================
// PRIVATE METHODS =
//==============================================================================
static void merge_ui_def(GebrGuiHelpEditWindow * window, gboolean revert_visible)
{
GtkActionGroup * action_group;
GtkUIManager * ui_manager;
GtkAction * action;
GError * error = NULL;
gchar * path;
ui_manager = gebr_gui_help_edit_window_get_ui_manager(window);
action_group = gtk_action_group_new("DebrHelpEditGroup");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions(action_group, action_entries, n_action_entries, window);
action = gtk_action_group_get_action(action_group, "JumpToMenu");
g_object_set(action, "hide-if-empty", FALSE, NULL);
action = gtk_action_group_get_action(action_group, "RevertAction");
gtk_action_set_sensitive(action, revert_visible);
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_string(ui_manager, ui_def, -1, &error);
g_object_unref(action_group);
path = g_strconcat (gebr_gui_help_edit_window_get_tool_bar_mark (window),
"/PreviewAction",
NULL);
action = gtk_ui_manager_get_action (ui_manager, path);
g_signal_connect (action, "toggled", G_CALLBACK (on_preview_toggled), window);
g_free (path);
if (error != NULL) {
g_warning("%s\n", error->message);
g_clear_error(&error);
}
}
PtpSimulatorUIManager *
ptp_simulator_ui_manager_new(void)
{
PtpSimulatorUIManager *ui_manager;
GtkActionGroup *menubar_action_group;
GError *error = NULL;
menubar_action_group = gtk_action_group_new("MenuActionGroup");
gtk_action_group_add_actions(menubar_action_group, /* the action group */
menubar_action_entries, /* an array of action descriptions */
G_N_ELEMENTS(menubar_action_entries), /* the number of entries */
NULL); /* data to pass to the action callbacks */
ui_manager = g_object_new(PTP_SIMULATOR_TYPE_UI_MANAGER, NULL);
gtk_ui_manager_insert_action_group(GTK_UI_MANAGER(ui_manager), menubar_action_group, 0);
gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), menubar_definition, -1, &error);
if (error != NULL) {
fprintf(stderr, "Warning: building menubar failed: %s\n", error->message);
g_error_free(error);
error = NULL;
}
g_object_unref(menubar_action_group);
return ui_manager;
}
void
edit_metadata__gth_browser_set_current_page_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
switch (gth_window_get_current_page (GTH_WINDOW (browser))) {
case GTH_BROWSER_PAGE_BROWSER:
if (data->viewer_ui_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->viewer_ui_merge_id);
data->viewer_ui_merge_id = 0;
}
break;
case GTH_BROWSER_PAGE_VIEWER:
if (data->viewer_ui_merge_id != 0)
return;
data->viewer_ui_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), viewer_ui_info, -1, &error);
if (data->viewer_ui_merge_id == 0) {
g_warning ("ui building failed: %s", error->message);
g_clear_error (&error);
}
break;
default:
break;
}
}
static void
entity_initgui(Tbfwin * bfwin)
{
GtkActionGroup *action_group;
GError *error = NULL;
static const GtkActionEntry entities_actions[] = {
{"CharactersToEntities", NULL, N_("C_haracters to Entities"), NULL,
N_("Change characters to entities"), G_CALLBACK(entity_char_to_entity)},
{"EntitiesToCharacters", NULL, N_("Ent_ities to Characters"), NULL,
N_("Change entities to characters"), G_CALLBACK(entity_entity_to_char)},
{"URLDecode", NULL, N_("URL _Decode"), NULL, N_("URL decode"), G_CALLBACK(entity_url_decode)},
{"URLEncode", NULL, N_("URL _Encode"), NULL, N_("URL encode"), G_CALLBACK(entity_url_encode)},
{"ToLowercase", NULL, N_("To Lo_wercase"), NULL, N_("To lowercase"), G_CALLBACK(entity_to_lowercase)},
{"ToUppercase", NULL, N_("To _Uppercase"), NULL, N_("To uppercase"), G_CALLBACK(entity_to_uppercase)}
};
action_group = gtk_action_group_new("EntitiesActions");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE "_plugin_entities");
gtk_action_group_add_actions(action_group, entities_actions, G_N_ELEMENTS(entities_actions), bfwin);
gtk_ui_manager_insert_action_group(bfwin->uimanager, action_group, 0);
g_object_unref(action_group);
gtk_ui_manager_add_ui_from_string(bfwin->uimanager, entities_plugin_ui, -1, &error);
if (error != NULL) {
g_warning("building entities plugin menu failed: %s", error->message);
g_error_free(error);
}
}
GtkUIManager *create_iijmio_uimanager(GtkWidget *window)
{
GtkUIManager *ui;
GtkActionGroup *action_group;
GError *error;
ui = gtk_ui_manager_new();
g_object_set_data_full(G_OBJECT(window),
"ui-manager", ui,
g_object_unref);
if (!gtk_ui_manager_add_ui_from_string(ui, ui_info, -1, &error)) {
g_message("Failed to build menus: %s\n", error->message);
g_error_free (error);
error = NULL;
}
action_group = gtk_action_group_new("IIJmioActions");
gtk_action_group_add_actions(action_group,
entries, n_entries,
window);
gtk_ui_manager_insert_action_group(ui, action_group, 0);
gtk_window_add_accel_group(GTK_WINDOW(window),
gtk_ui_manager_get_accel_group(ui));
return ui;
}
GtkWidget *toolbar_init(GtkWindow *parent)
{
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
GtkToolbar *toolbar;
GtkActionGroup *ag = gtk_action_group_new("Actions");
gtk_action_group_add_actions(ag, action_items,
G_N_ELEMENTS(action_items), parent);
gtk_action_group_add_toggle_actions(ag, toggle_items,
G_N_ELEMENTS(toggle_items), parent);
GtkUIManager *ui = gtk_ui_manager_new();
g_object_set_data(G_OBJECT(parent), "ui_manager", ui);
gtk_ui_manager_insert_action_group(ui, ag, 0);
GtkAccelGroup *accel = gtk_ui_manager_get_accel_group(ui);
gtk_window_add_accel_group(parent, accel);
GError *error = NULL;
if (!gtk_ui_manager_add_ui_from_string (ui, ui_xml, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
exit (-1);
}
GtkWidget *menubar = gtk_ui_manager_get_widget(ui, "/menubar");
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menubar), FALSE, TRUE, 0);
toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget(ui, "/toolbar"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), FALSE, TRUE, 0);
/* Device selection GtkComboBox */
GtkToolItem *toolitem = gtk_tool_item_new();
GtkWidget *dev = dev_select_combo_box_new(parent);
gtk_container_add(GTK_CONTAINER(toolitem), dev);
gtk_toolbar_insert(toolbar, toolitem, 0);
/* Time/Samples entry */
toolitem = gtk_tool_item_new();
GtkWidget *timesamples = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(timesamples), "100");
gtk_entry_set_alignment(GTK_ENTRY(timesamples), 1.0);
gtk_widget_set_size_request(timesamples, 100, -1);
gtk_container_add(GTK_CONTAINER(toolitem), timesamples);
gtk_toolbar_insert(toolbar, toolitem, 7);
/* Time unit combo box */
toolitem = gtk_tool_item_new();
GtkWidget *timeunit = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "samples");
gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "ms");
gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "s");
gtk_combo_box_set_active(GTK_COMBO_BOX(timeunit), 0);
gtk_container_add(GTK_CONTAINER(toolitem), timeunit);
gtk_toolbar_insert(toolbar, toolitem, 8);
g_object_set_data(G_OBJECT(parent), "timesamples", timesamples);
g_object_set_data(G_OBJECT(parent), "timeunit", timeunit);
return GTK_WIDGET(vbox);
}
static void
nautilus_toolbar_constructed (GObject *obj)
{
NautilusToolbar *self = NAUTILUS_TOOLBAR (obj);
GtkToolItem *item;
GtkWidget *hbox, *toolbar, *search;
GtkStyleContext *context;
const gchar *ui;
G_OBJECT_CLASS (nautilus_toolbar_parent_class)->constructed (obj);
gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)),
GTK_JUNCTION_BOTTOM);
/* add the UI */
ui = nautilus_ui_string_get ("nautilus-toolbar-ui.xml");
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_add_ui_from_string (self->priv->ui_manager, ui, -1, NULL);
gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0);
toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar");
self->priv->toolbar = toolbar;
context = gtk_widget_get_style_context (toolbar);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
search = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar/Search");
gtk_style_context_add_class (gtk_widget_get_style_context (search), GTK_STYLE_CLASS_RAISED);
gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0);
gtk_widget_show_all (self->priv->toolbar);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (hbox);
/* regular path bar */
self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL);
gtk_box_pack_start (GTK_BOX (hbox), self->priv->path_bar, TRUE, TRUE, 0);
/* entry-like location bar */
self->priv->location_bar = nautilus_location_bar_new ();
gtk_box_pack_start (GTK_BOX (hbox), self->priv->location_bar, TRUE, TRUE, 0);
item = gtk_tool_item_new ();
gtk_tool_item_set_expand (item, TRUE);
gtk_container_add (GTK_CONTAINER (item), hbox);
gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
/* search bar */
self->priv->search_bar = nautilus_search_bar_new ();
gtk_box_pack_start (GTK_BOX (self), self->priv->search_bar, TRUE, TRUE, 0);
g_signal_connect_swapped (nautilus_preferences,
"changed::" NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY,
G_CALLBACK (toolbar_update_appearance), self);
toolbar_update_appearance (self);
}
static void
menus_init(void)
{
GError *error = NULL;
gchar *uifile;
if (!initialise)
return;
initialise = FALSE;
_setup_global_actions ();
uifile = build_ui_filename ("ui/toolbox-ui.xml");
if (!gtk_ui_manager_add_ui_from_file (_ui_manager, uifile, &error)) {
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
error = NULL;
}
g_free (uifile);
/* the display menu */
display_actions = create_or_ref_display_actions (TRUE);
display_ui_manager = gtk_ui_manager_new ();
g_signal_connect (G_OBJECT (display_ui_manager),
"connect_proxy",
G_CALLBACK (_ui_manager_connect_proxy),
NULL);
gtk_ui_manager_set_add_tearoffs (display_ui_manager, DIA_SHOW_TEAROFFS);
gtk_ui_manager_insert_action_group (display_ui_manager, display_actions, 0);
gtk_ui_manager_insert_action_group (display_ui_manager, tool_actions, 0);
if (!gtk_ui_manager_add_ui_from_string (display_ui_manager, ui_info, -1, &error)) {
g_warning ("built-in menus failed: %s", error->message);
g_error_free (error);
error = NULL;
}
uifile = build_ui_filename ("ui/popup-ui.xml");
/* TODO it would be more elegant if we had only one definition of the
* menu hierarchy and merge it into a popup somehow. */
if (!gtk_ui_manager_add_ui_from_file (display_ui_manager, uifile, &error)) {
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
error = NULL;
}
g_free (uifile);
display_accels = gtk_ui_manager_get_accel_group (display_ui_manager);
display_menubar = gtk_ui_manager_get_widget (display_ui_manager, DISPLAY_MENU);
g_assert (display_menubar);
add_plugin_actions (_ui_manager, TOOLBOX_MENU);
add_plugin_actions (display_ui_manager, DISPLAY_MENU);
add_plugin_actions (display_ui_manager, INVISIBLE_MENU);
/* after creating all menu items */
load_accels ();
}
static GtkUIManager *
remap_ui_manager_new (GtkWidget *window,
GtkListStore *store)
{
static const GtkActionEntry actions[] =
{
{
"sort-hue", NULL, N_("Sort on Hue"), NULL, NULL,
G_CALLBACK (remap_sort_callback)
},
{
"sort-sat", NULL, N_("Sort on Saturation"), NULL, NULL,
G_CALLBACK (remap_sort_callback)
},
{
"sort-val", NULL, N_("Sort on Value"), NULL, NULL,
G_CALLBACK (remap_sort_callback)
},
{
"reverse", NULL, N_("Reverse Order"), NULL, NULL,
G_CALLBACK (remap_reverse_callback)
},
{
"reset", GIMP_STOCK_RESET, N_("Reset Order"), NULL, NULL,
G_CALLBACK (remap_reset_callback)
},
};
GtkUIManager *ui_manager = gtk_ui_manager_new ();
GtkActionGroup *group = gtk_action_group_new ("Actions");
GError *error = NULL;
gtk_action_group_set_translation_domain (group, NULL);
gtk_action_group_add_actions (group, actions, G_N_ELEMENTS (actions), store);
gtk_ui_manager_insert_action_group (ui_manager, group, -1);
g_object_unref (group);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <popup name=\"remap-popup\">"
" <menuitem action=\"sort-hue\" />"
" <menuitem action=\"sort-sat\" />"
" <menuitem action=\"sort-val\" />"
" <separator />"
" <menuitem action=\"reverse\" />"
" <menuitem action=\"reset\" />"
" </popup>"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
return ui_manager;
}
static void
e_mapi_config_ui_extension_shell_view_toggled_cb (EShellView *shell_view,
EMapiConfigUIExtension *ui_ext)
{
EShellViewClass *shell_view_class;
EShellWindow *shell_window;
GtkUIManager *ui_manager;
gpointer key = NULL, value = NULL;
const gchar *ui_def;
gboolean is_active, need_update;
g_return_if_fail (E_IS_SHELL_VIEW (shell_view));
g_return_if_fail (ui_ext != NULL);
shell_view_class = E_SHELL_VIEW_GET_CLASS (shell_view);
g_return_if_fail (shell_view_class != NULL);
shell_window = e_shell_view_get_shell_window (shell_view);
ui_manager = e_shell_window_get_ui_manager (shell_window);
need_update = ui_ext->current_ui_id != 0;
if (ui_ext->current_ui_id) {
gtk_ui_manager_remove_ui (ui_manager, ui_ext->current_ui_id);
ui_ext->current_ui_id = 0;
}
is_active = e_shell_view_is_active (shell_view);
if (!is_active) {
if (need_update)
gtk_ui_manager_ensure_update (ui_manager);
return;
}
if (!g_hash_table_lookup_extended (ui_ext->ui_definitions, shell_view_class->ui_manager_id, &key, &value)) {
gchar *ui_definition = NULL;
e_mapi_config_utils_init_ui (shell_view, shell_view_class->ui_manager_id, &ui_definition);
g_hash_table_insert (ui_ext->ui_definitions, g_strdup (shell_view_class->ui_manager_id), ui_definition);
}
ui_def = g_hash_table_lookup (ui_ext->ui_definitions, shell_view_class->ui_manager_id);
if (ui_def) {
GError *error = NULL;
ui_ext->current_ui_id = gtk_ui_manager_add_ui_from_string (ui_manager, ui_def, -1, &error);
need_update = TRUE;
if (error) {
g_warning ("%s: Failed to add ui definition: %s", G_STRFUNC, error->message);
g_error_free (error);
}
}
if (need_update)
gtk_ui_manager_ensure_update (ui_manager);
}
