static gboolean
menu_cb (WebKitWebView *v, GtkWidget *menu, WebKitHitTestResult *hit, gboolean kb, gpointer d)
{
GtkWidget *mi;
#if 0
if (!is_link)
{
/* add open item */
mi = gtk_separator_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
mi = gtk_image_menu_item_new_from_stock ("gtk-open", NULL);
gtk_widget_show (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (open_cb), NULL);
/* add quit item */
mi = gtk_separator_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
mi = gtk_image_menu_item_new_from_stock ("gtk-quit", NULL);
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gtk_main_quit), NULL);
}
#endif
return FALSE;
}
static void
populate_popup (GtkTextView *textview, GtkMenu *menu, GeditAutomaticSpellChecker *spell)
{
GtkWidget *img, *mi;
GtkTextIter start, end;
char *word;
/* we need to figure out if they picked a misspelled word. */
get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click);
/* if our highlight algorithm ever messes up,
* this isn't correct, either. */
if (!gtk_text_iter_has_tag (&start, spell->tag_highlight))
return; /* word wasn't misspelled. */
/* menu separator comes first. */
mi = gtk_separator_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
/* then, on top of it, the suggestions menu. */
img = gtk_image_new_from_stock (GTK_STOCK_SPELL_CHECK, GTK_ICON_SIZE_MENU);
mi = gtk_image_menu_item_new_with_mnemonic (_("_Spelling Suggestions..."));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), &start, &end, FALSE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi),
build_suggestion_menu (spell, word));
g_free(word);
gtk_widget_show_all (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
}
static void
populate_entry_popup(GtkTextView *text, GtkMenu *menu, JamView *view) {
GtkWidget *menu_item;
g_return_if_fail(menu != NULL);
g_return_if_fail(GTK_IS_MENU_SHELL(menu));
menu_item = gtk_separator_menu_item_new();
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, NULL);
gtk_widget_set_sensitive(menu_item,
undomgr_can_redo(view->undomgr));
g_signal_connect_swapped(G_OBJECT(menu_item), "activate",
G_CALLBACK(redo_cb), view);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, NULL);
gtk_widget_set_sensitive(menu_item,
undomgr_can_undo(view->undomgr));
g_signal_connect_swapped(G_OBJECT(menu_item), "activate",
G_CALLBACK(undo_cb), view);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
}
static void
egg_find_bar_entry_populate_popup (EggFindBar *find_bar,
GtkWidget *menu)
{
GtkWidget *menu_item;
if (find_bar->priv->whole_words_only_enabled)
{
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Whole Words Only"));
g_signal_connect (menu_item, "toggled",
G_CALLBACK (whole_words_only_toggled_callback),
find_bar);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
find_bar->priv->whole_words_only);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
if (find_bar->priv->case_sensitive_enabled)
{
menu_item = gtk_check_menu_item_new_with_mnemonic (_("C_ase Sensitive"));
g_signal_connect (menu_item, "toggled",
G_CALLBACK (case_sensitive_toggled_callback),
find_bar);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
find_bar->priv->case_sensitive);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
}
AwnApplet*
awn_applet_factory_initp ( gchar* uid, gint orient, gint height )
{
AwnApplet *applet = awn_applet_new( uid, orient, height );
GtkWidget *trash;
GtkWidget *menu;
GtkWidget *item;
gnome_vfs_init ();
/* trash */
trash = trash_applet_new (applet);
/* menu */
menu = awn_applet_create_default_menu (applet);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (show_about), trash);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (show_help), trash);
item = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_mnemonic ("_Empty the Wastebasket");
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (empty_trash), trash);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (open_trash), trash);
g_signal_connect (G_OBJECT (applet), "button-release-event",
G_CALLBACK (applet_button_release), menu);
gtk_widget_set_size_request (GTK_WIDGET (applet),
awn_applet_get_height (applet),
awn_applet_get_height (applet) * 2);
gtk_container_add (GTK_CONTAINER (applet), trash);
gtk_widget_show_all (GTK_WIDGET (menu));
return applet;
}
static void dclock_generate_copy_to_clipboard_menu(GtkMenu* panel_menu, Plugin * plugin)
{
time_t now;
time(&now);
struct tm * current_time;
current_time = localtime(&now);
gchar ** formats = dclock_get_format_strings(plugin);
if(!formats)
return;
GtkWidget * menu = gtk_menu_new();
gboolean empty = TRUE;
int i;
for (i = 0; formats[i]; i++)
{
gchar * format = g_strstrip(formats[i]);
if (format[0] == 0 || format[0] == '#')
continue;
if (strcmp(format, "-") == 0)
{
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
continue;
}
char buf[128];
strftime(buf, 128, format, current_time);
GtkWidget* item = gtk_menu_item_new_with_label(buf);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(dclock_copy_to_clipboard_menu_item_activate), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
empty = FALSE;
}
g_strfreev(formats);
if (empty)
{
g_object_ref_sink(G_OBJECT(menu));
g_object_unref(G_OBJECT(menu));
}
else
{
gtk_menu_shell_prepend(GTK_MENU_SHELL(panel_menu), wtl_gtk_widget_show(gtk_separator_menu_item_new()));
GtkWidget * copy_to_clipboard = gtk_menu_item_new_with_label(_("Copy to Clipboard..."));
gtk_menu_shell_prepend(GTK_MENU_SHELL(panel_menu), copy_to_clipboard);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(copy_to_clipboard), menu);
gtk_widget_show(copy_to_clipboard);
gtk_widget_show_all(menu);
}
}
static GtkWidget *
create_recent_chooser_menu (gint limit)
{
GtkWidget *menu;
GtkRecentFilter *filter;
GtkWidget *menuitem;
menu = gtk_recent_chooser_menu_new_for_manager (manager);
if (limit > 0)
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (menu), limit);
gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (menu),
GTK_RECENT_SORT_MRU);
gtk_recent_chooser_menu_set_show_numbers (GTK_RECENT_CHOOSER_MENU (menu),
TRUE);
filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter, "Gedit files");
gtk_recent_filter_add_application (filter, "gedit");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (menu), filter);
g_signal_connect (menu, "item-activated",
G_CALLBACK (item_activated_cb),
NULL);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Test prepend");
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Test append");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_mnemonic ("Clear");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_show_all (menu);
return menu;
}
static VALUE
rg_prepend(VALUE self, VALUE child)
{
gtk_menu_shell_prepend(_SELF(self), RVAL2GTKWIDGET(child));
G_CHILD_ADD(self, child);
return self;
}
static GtkWidget *browserWindowCreateBackForwardMenu(BrowserWindow *window, GList *list)
{
if (!list)
return NULL;
GtkWidget *menu = gtk_menu_new();
GList *listItem;
for (listItem = list; listItem; listItem = g_list_next(listItem)) {
WebKitBackForwardListItem *item = (WebKitBackForwardListItem *)listItem->data;
const char *uri = webkit_back_forward_list_item_get_uri(item);
const char *title = webkit_back_forward_list_item_get_title(item);
GtkAction *action = gtk_action_new(uri, title, NULL, NULL);
g_object_set_data_full(G_OBJECT(action), "back-forward-list-item", g_object_ref(item), g_object_unref);
g_signal_connect_swapped(action, "activate", G_CALLBACK(browserWindowHistoryItemActivated), window);
GtkWidget *menuItem = gtk_action_create_menu_item(action);
g_signal_connect_swapped(menuItem, "select", G_CALLBACK(browserWindowHistoryItemSelected), window);
g_object_unref(action);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuItem);
gtk_widget_show(menuItem);
}
g_signal_connect(menu, "hide", G_CALLBACK(resetStatusText), window);
return menu;
}
static void
ide_editor_spell_widget__populate_popup_cb (IdeEditorSpellWidget *self,
GtkWidget *popup,
GtkEntry *entry)
{
GSList *suggestions = NULL;
const gchar *text;
GtkWidget *item;
gint count = 0;
g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self));
g_assert (GTK_IS_WIDGET (popup));
g_assert (GTK_IS_ENTRY (entry));
text = gtk_entry_get_text (entry);
if (self->is_word_entry_valid ||
ide_str_empty0 (text) ||
NULL == (suggestions = gspell_checker_get_suggestions (self->checker, text, -1)))
return;
item = g_object_new (GTK_TYPE_SEPARATOR_MENU_ITEM,
"visible", TRUE,
NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (popup), item);
suggestions = g_slist_reverse (suggestions);
for (GSList *l = (GSList *)suggestions; l != NULL; l = l->next)
{
item = g_object_new (GTK_TYPE_MENU_ITEM,
"label", l->data,
"visible", TRUE,
NULL);
g_object_set_data (G_OBJECT (item), "word", g_strdup (l->data));
gtk_menu_shell_prepend (GTK_MENU_SHELL (popup), item);
g_signal_connect_object (item,
"activate",
G_CALLBACK (ide_editor_spell_widget__word_entry_suggestion_activate),
self,
G_CONNECT_SWAPPED);
if (++count >= WORD_ENTRY_MAX_SUGGESTIONS)
break;
}
g_slist_free_full (suggestions, g_free);
}
void gprj_menu_init()
{
GtkWidget *image;
s_sep_item = gtk_separator_menu_item_new();
gtk_widget_show(s_sep_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_sep_item);
image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
s_fif_item = gtk_image_menu_item_new_with_mnemonic(_("Find in Project Files"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(s_fif_item), image);
gtk_widget_show(s_fif_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_fif_item);
g_signal_connect((gpointer) s_fif_item, "activate", G_CALLBACK(on_find_in_project), NULL);
keybindings_set_item(plugin_key_group, KB_FIND_IN_PROJECT, kb_callback,
0, 0, "find_in_project", _("Find in project files"), s_fif_item);
image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
s_ff_item = gtk_image_menu_item_new_with_mnemonic(_("Find Project File"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(s_ff_item), image);
gtk_widget_show(s_ff_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_ff_item);
g_signal_connect((gpointer) s_ff_item, "activate", G_CALLBACK(on_find_file), NULL);
keybindings_set_item(plugin_key_group, KB_FIND_FILE, kb_callback,
0, 0, "find_file", _("Find project file"), s_ff_item);
s_shs_item = gtk_menu_item_new_with_mnemonic(_("Swap Header/Source"));
gtk_widget_show(s_shs_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_shs_item);
g_signal_connect((gpointer) s_shs_item, "activate", G_CALLBACK(on_swap_header_source), NULL);
keybindings_set_item(plugin_key_group, KB_SWAP_HEADER_SOURCE, kb_callback,
0, 0, "swap_header_source", _("Swap header/source"), s_shs_item);
s_context_sep_item = gtk_separator_menu_item_new();
gtk_widget_show(s_context_sep_item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_sep_item);
s_context_osf_item = gtk_menu_item_new_with_mnemonic(_("Open Selected File (gproject)"));
gtk_widget_show(s_context_osf_item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_osf_item);
g_signal_connect((gpointer) s_context_osf_item, "activate", G_CALLBACK(on_open_selected_file), NULL);
gprj_menu_activate_menu_items(FALSE);
}
static void log_window_popup_menu_extend(GtkTextView *textview,
GtkMenu *menu, LogWindow *logwin)
{
GtkWidget *menuitem;
cm_return_if_fail(menu != NULL);
cm_return_if_fail(GTK_IS_MENU_SHELL(menu));
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show(menuitem);
menuitem = gtk_menu_item_new_with_mnemonic(_("Clear _Log"));
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(log_window_clear), logwin);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show(menuitem);
}
static void
file_entry_populate_popup (GtkEntry *entry, GtkMenu *menu, gpointer storage)
{
GtkWidget *submenu, *item;
GtkWidget *entry_file;
item = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_mnemonic (_("Selection to"));
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
submenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
item = gtk_menu_item_new_with_label (_("Title"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_title), storage);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
item = gtk_menu_item_new_with_label (_("Artist"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_artist), storage);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
item = gtk_menu_item_new_with_label (_("Album"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_album), storage);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
item = gtk_menu_item_new_with_label (_("Genre"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_genre), storage);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
item = gtk_menu_item_new_with_label (_("Comment"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_comment), storage);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
gtk_widget_show_all (submenu);
entry_file = g_object_get_data (storage, "entry_file");
if (!gtk_editable_get_selection_bounds (GTK_EDITABLE(entry_file), NULL, NULL))
gtk_widget_set_sensitive (submenu, FALSE);
item = gtk_menu_item_new_with_mnemonic (_("Open folder"));
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_open_folder), storage);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
static gboolean
widget_undo_prepend_popup (GtkWidget *widget,
GtkMenuShell *menu,
EUndoDoType undo_type,
gboolean already_added)
{
gchar *description = NULL;
const gchar *icon_name = NULL;
if (undo_type == E_UNDO_DO_UNDO && e_widget_undo_has_undo (widget)) {
description = e_widget_undo_describe_undo (widget);
icon_name = "edit-undo";
} else if (undo_type == E_UNDO_DO_REDO && e_widget_undo_has_redo (widget)) {
description = e_widget_undo_describe_redo (widget);
icon_name = "edit-redo";
}
if (description) {
GtkWidget *item, *image;
if (!already_added) {
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_shell_prepend (menu, item);
already_added = TRUE;
}
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
item = gtk_image_menu_item_new_with_label (description);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_widget_show (item);
g_object_set_data (G_OBJECT (item), UNDO_DATA_KEY, GINT_TO_POINTER (undo_type));
g_signal_connect (item, "activate", G_CALLBACK (widget_undo_popup_activate_cb), widget);
gtk_menu_shell_prepend (menu, item);
g_free (description);
}
return already_added;
}
static void
dma_data_view_populate_popup (GtkTextView *widget,
GtkMenu *menu,
DmaDataView *view)
{
GtkWidget *menu_item;
/* separator */
menu_item = gtk_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
/* create goto menu_item. */
menu_item = gtk_menu_item_new_with_mnemonic (_("_Go to address"));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (dma_data_view_goto_activate), view);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
static void
list_popup_cb (GdauiRawGrid *grid, GtkMenu *menu, gpointer user_data)
{
GtkWidget *item_delete;
gboolean ok;
GArray *selection;
item_delete = new_menu_item (_("_Delete"),
G_CALLBACK (list_popup_delete_cb),
user_data);
selection = gdaui_data_selector_get_selected_rows (GDAUI_DATA_SELECTOR (grid));
ok = (selection != NULL);
if (selection)
g_array_free (selection, TRUE);
gtk_widget_set_sensitive (item_delete, ok);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), gtk_separator_menu_item_new ());
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item_delete);
}
/**
* Adds a teaoroff menuitem if there isn't one already and the gconf option is set
*/
void
gul_gui_setup_tearoff (GtkMenuShell *ms)
{
gboolean has_tearoff = eel_gconf_get_boolean ("/desktop/gnome/interface/menus_have_tearoff");
if (has_tearoff && !gul_gui_menu_shell_has_tearoff (ms))
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_widget_show (tearoff);
gtk_menu_shell_prepend (ms, tearoff);
}
}
int
clip_GTK_MENUSHELLPREPEND(ClipMachine * cm)
{
C_widget *cmns = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cmns,GTK_IS_MENU_SHELL);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_menu_shell_prepend(GTK_MENU_SHELL(cmns->widget), cwid->widget);
return 0;
err:
return 1;
}
/* like gtk_menu_shell_insert, but appends/prepends if @position is out
* of range */
static void
menu_shell_insert (GtkMenuShell *shell,
GtkWidget *item,
gint position)
{
if (position <= 0) {
gtk_menu_shell_prepend (shell, item);
}
else {
GList *children = gtk_container_get_children (GTK_CONTAINER (shell));
if (children) {
if (position < g_list_length (children))
gtk_menu_shell_insert (shell, item, position);
else
gtk_menu_shell_append (shell, item);
g_list_free (children);
}
else
gtk_menu_shell_prepend (shell, item);
}
}
void plugin_init(G_GNUC_UNUSED GeanyData * data)
{
GeanyKeyGroup *key_group = plugin_set_key_group(geany_plugin, "GeanyCtags", KB_COUNT, kb_callback);
s_context_sep_item = gtk_separator_menu_item_new();
gtk_widget_show(s_context_sep_item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_sep_item);
s_context_fdec_item = gtk_menu_item_new_with_mnemonic(_("Find Tag Declaration (geanyctags)"));
gtk_widget_show(s_context_fdec_item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_fdec_item);
g_signal_connect((gpointer) s_context_fdec_item, "activate", G_CALLBACK(on_find_declaration), NULL);
s_context_fdef_item = gtk_menu_item_new_with_mnemonic(_("Find Tag Definition (geanyctags)"));
gtk_widget_show(s_context_fdef_item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(geany->main_widgets->editor_menu), s_context_fdef_item);
g_signal_connect((gpointer) s_context_fdef_item, "activate", G_CALLBACK(on_find_definition), NULL);
s_sep_item = gtk_separator_menu_item_new();
gtk_widget_show(s_sep_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_sep_item);
s_gt_item = gtk_menu_item_new_with_mnemonic(_("Generate tags"));
gtk_widget_show(s_gt_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_gt_item);
g_signal_connect((gpointer) s_gt_item, "activate", G_CALLBACK(on_generate_tags), NULL);
keybindings_set_item(key_group, KB_GENERATE_TAGS, NULL,
0, 0, "generate_tags", _("Generate tags"), s_gt_item);
s_ft_item = gtk_menu_item_new_with_mnemonic(_("Find tag..."));
gtk_widget_show(s_ft_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->project_menu), s_ft_item);
g_signal_connect((gpointer) s_ft_item, "activate", G_CALLBACK(on_find_tag), NULL);
keybindings_set_item(key_group, KB_FIND_TAG, NULL,
0, 0, "find_tag", _("Find tag"), s_ft_item);
set_widgets_sensitive(geany_data->app->project != NULL);
}
static void
add_popup_menu_items (GtkWidget *menu,
GeditViewFrame *frame)
{
GtkWidget *menu_item;
/* create "Wrap Around" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (wrap_around_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
frame->priv->wrap_around);
gtk_widget_show (menu_item);
/* create "Match Entire Word Only" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (match_entire_word_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
GEDIT_SEARCH_IS_ENTIRE_WORD (frame->priv->search_flags));
gtk_widget_show (menu_item);
/* create "Match Case" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (match_case_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
GEDIT_SEARCH_IS_CASE_SENSITIVE (frame->priv->search_flags));
gtk_widget_show (menu_item);
}
static void
populate_popup_cb (G_GNUC_UNUSED GtkWidget *text_view, GtkMenu *menu, EntryProperties *eprop)
{
GtkTextIter iter;
gtk_text_view_get_iter_at_position (eprop->priv->view, &iter, NULL,
eprop->priv->bx, eprop->priv->by);
GSList *tags = NULL, *tagp = NULL;
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next) {
GtkTextTag *tag = tagp->data;
GValue *binvalue;
binvalue = g_object_get_data (G_OBJECT (tag), "binvalue");
if (binvalue) {
GtkWidget *item;
item = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label (_("Save"));
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (data_save_cb), eprop);
g_object_set_data (G_OBJECT (item), "binvalue", binvalue);
gtk_widget_show (item);
break;
}
}
if (tags)
g_slist_free (tags);
}
static void tracker_cb(fitbitd_tracker_t *tracker, void *user)
{
IndicatorFitbit *self = user;
GtkWidget *item = tracker->user;
if (!item) {
item = tracker_menuitem_new();
tracker->user = item;
gtk_widget_show(item);
gtk_menu_shell_prepend(GTK_MENU_SHELL(self->priv->menu), item);
}
self->priv->syncing |= tracker->sync_active;
update_icon(self);
tracker_menuitem_set_from_tracker(TRACKER_MENUITEM(item), tracker);
}
static void
entry_populate_popup_callback (GtkEntry *entry,
GtkMenu *menu,
void *data)
{
EggFindBar *find_bar = EGG_FIND_BAR (data);
GtkWidget *separator;
if (!find_bar->priv->case_sensitive_enabled &&
!find_bar->priv->whole_words_only_enabled)
return;
separator = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), separator);
gtk_widget_show (separator);
egg_find_bar_entry_populate_popup (find_bar, GTK_WIDGET (menu));
}
static void
view_popup_menu(GtkButton * button, GdkEventButton * event,
GtkTreeViewColumn * column)
{
GtkWidget *tv = gtk_tree_view_column_get_tree_view(column);
TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv);
GtkWidget *menu, *menuitem;
trg_column_description *desc;
guint n_showing = 0;
GList *li;
menu = gtk_menu_new();
desc = g_object_get_data(G_OBJECT(column), GDATA_KEY_COLUMN_DESC);
for (li = priv->columns; li; li = g_list_next(li)) {
trg_column_description *desc = (trg_column_description *) li->data;
if (!(desc->flags & TRG_COLUMN_SHOWING)) {
menuitem = gtk_check_menu_item_new_with_label(desc->header);
g_object_set_data(G_OBJECT(menuitem), "parent-col", column);
g_signal_connect(menuitem, "activate",
G_CALLBACK(trg_tree_view_user_add_column_cb),
desc);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
} else {
n_showing++;
}
}
menuitem = gtk_check_menu_item_new_with_label(desc->header);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
g_signal_connect(menuitem, "activate",
G_CALLBACK(trg_tree_view_hide_column), column);
gtk_widget_set_sensitive(menuitem,
!(desc->flags & TRG_COLUMN_UNREMOVABLE) && n_showing > 1);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *) event));
}
static void
search_entry_populate_popup (GtkEntry *entry,
GtkMenu *menu,
GeditViewFrame *frame)
{
GtkWidget *menu_item;
frame->priv->disable_popdown = TRUE;
g_signal_connect (menu, "hide",
G_CALLBACK (search_enable_popdown), frame);
if (frame->priv->search_mode == GOTO_LINE)
return;
/* separator */
menu_item = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
add_popup_menu_items (GTK_WIDGET (menu), frame);
}
static gboolean remmina_icon_foreach_window(GtkWidget *widget, gpointer data)
{
GtkWidget *popup_menu = GTK_WIDGET(data);
GtkWidget *menuitem;
GdkScreen *screen;
gint screen_number;
if (G_TYPE_CHECK_INSTANCE_TYPE(widget, REMMINA_TYPE_CONNECTION_WINDOW))
{
screen = gdk_screen_get_default();
screen_number = gdk_screen_get_number(screen);
if (screen_number == gdk_screen_get_number(gtk_window_get_screen(GTK_WINDOW(widget))))
{
menuitem = gtk_menu_item_new_with_label(gtk_window_get_title(GTK_WINDOW(widget)));
gtk_widget_show(menuitem);
gtk_menu_shell_prepend(GTK_MENU_SHELL(popup_menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_icon_on_activate_window), widget);
return TRUE;
}
}
return FALSE;
}
void populate_note_popup(GtkTextView *entry, GtkMenu *menu, Note *note)
{
GtkWidget *color_menu;
GtkWidget *color_item;
GtkWidget *item;
GtkWidget *label;
GtkWidget *color_box;
GtkWidget *hbox;
GdkColor gcolor;
int i;
color_menu = gtk_menu_new();
color_item = gtk_menu_item_new_with_label("Color");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(color_item), color_menu);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), color_item);
current_note = note;
for(i=0; i < num_color_schemes; i++) {
item = gtk_menu_item_new();
label = gtk_label_new(color_schemes[i].name);
color_box = gtk_event_box_new();
gtk_widget_set_size_request(color_box, 15, -1);
hbox = gtk_hbox_new(FALSE, 4);
gdk_color_parse(color_schemes[i].top, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_NORMAL, &gcolor);
gtk_widget_modify_bg(color_box, GTK_STATE_PRELIGHT, &gcolor);
gtk_container_add(GTK_CONTAINER(item), hbox);
gtk_box_pack_start(GTK_BOX(hbox), color_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_menu_shell_append(GTK_MENU_SHELL(color_menu), item);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(set_current_note_color), &color_schemes[i]);
}
gtk_widget_show_all(GTK_WIDGET(menu));
}
static void
is_indicator_constructed(GObject *object)
{
IsIndicator *self = IS_INDICATOR(object);
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GError *error = NULL;
GtkWidget *menu;
action_group = gtk_action_group_new("AppActions");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions(action_group,
entries, n_entries,
self);
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_info, -1, &error))
{
g_error("Failed to build menus: %s\n", error->message);
}
menu = gtk_ui_manager_get_widget(ui_manager, "/ui/Indicator");
/* manually add separator since specifying it in the ui description
means it gets optimised out (since there is no menu item above it)
but if we manually add it and show the whole menu then all is
good... */
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
gtk_widget_show_all(menu);
is_indicator_set_label(self, _("No Sensors"));
is_indicator_set_menu(self, GTK_MENU(menu));
#if HAVE_APPINDICATOR
app_indicator_set_status(APP_INDICATOR(self), APP_INDICATOR_STATUS_ACTIVE);
#endif
fake_add_enable_sensors(IS_INDICATOR(object));
}
GTKFieldDiagWindow::GTKFieldDiagWindow( GTKPlotter &plotter, const Geometry &geom, size_t N,
const Vec3D &x1, const Vec3D &x2,
const field_diag_type_e diag[2],
const field_loc_type_e loc[2] )
: GTKFrameWindow(plotter), _geom(geom), _plot(_frame,geom)
{
_plot.set_epot( plotter.get_epot() );
_plot.set_efield( plotter.get_efield() );
_plot.set_scharge( plotter.get_scharge() );
_plot.set_bfield( plotter.get_bfield() );
_plot.set_coordinates( N, x1, x2 );
_plot.set_diagnostic( diag, loc );
// Set window title
gtk_window_set_title( GTK_WINDOW(_window), "Field diagnostics" );
// Add export menu item
GtkWidget *item_export = gtk_menu_item_new_with_mnemonic( "_Export" );
gtk_menu_shell_prepend( GTK_MENU_SHELL(_menu_file), item_export );
g_signal_connect( G_OBJECT(item_export), "activate",
G_CALLBACK(menuitem_export_signal),
(gpointer)this );
try {
_plot.build_plot();
} catch( Error e ) {
// Destroy window
gtk_widget_destroy( _window );
//plotter->delete_window( this ); Didn't work, still got window and pressing 'X' caused seg fault
throw e;
}
_frame.get_ranges( PLOT_AXIS_X1, _x1min, _x1max );
_frame.get_ranges( PLOT_AXIS_X1, _x2min, _x2max );
show();
}
