static GtkWidget *create_message_popup_menu(gint type)
{
GtkWidget *message_popup_menu, *clear, *copy, *copy_all, *image;
message_popup_menu = gtk_menu_new();
clear = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLEAR, NULL);
gtk_widget_show(clear);
gtk_container_add(GTK_CONTAINER(message_popup_menu), clear);
g_signal_connect(clear, "activate",
G_CALLBACK(on_message_treeview_clear_activate), GINT_TO_POINTER(type));
copy = gtk_image_menu_item_new_with_mnemonic(_("C_opy"));
gtk_widget_show(copy);
gtk_container_add(GTK_CONTAINER(message_popup_menu), copy);
image = gtk_image_new_from_stock(GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(copy), image);
g_signal_connect(copy, "activate",
G_CALLBACK(on_compiler_treeview_copy_activate), GINT_TO_POINTER(type));
copy_all = gtk_image_menu_item_new_with_mnemonic(_("Copy _All"));
gtk_widget_show(copy_all);
gtk_container_add(GTK_CONTAINER(message_popup_menu), copy_all);
image = gtk_image_new_from_stock(GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(copy_all), image);
g_signal_connect(copy_all, "activate",
G_CALLBACK(on_compiler_treeview_copy_all_activate), GINT_TO_POINTER(type));
msgwin_menu_add_common_items(GTK_MENU(message_popup_menu));
return message_popup_menu;
}
void ShowTrayMenu()
{
GtkWidget *menu;
GtkWidget *menu_item;
GtkWidget *icon;
int button, event_time;
menu = gtk_menu_new ();
//g_signal_connect (menu, "deactivate", G_CALLBACK(gtk_widget_destroy), NULL);
GtkAccelGroup *accel_group = gtk_accel_group_new();
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
// ... add menu items with accelerators ...
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Restore"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_restore), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Quit"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_quit), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
event_time = gtk_get_current_event_time ();
button = 0; //FIX: allow mouse button to trigger the submenu
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
}
static void georef_layer_add_menu_items ( VikGeorefLayer *vgl, GtkMenu *menu, gpointer vlp )
{
static gpointer pass_along[2];
GtkWidget *item;
pass_along[0] = vgl;
pass_along[1] = vlp;
item = gtk_menu_item_new();
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
/* Now with icons */
item = gtk_image_menu_item_new_with_mnemonic ( _("_Zoom to Fit Map") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(georef_layer_zoom_to_fit), pass_along );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Goto Map Center") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(georef_layer_goto_center), pass_along );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Export to World File") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_HARDDISK, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(georef_layer_export_params), pass_along );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
}
static GtkWidget *
create_tree_popup_menu (EomPluginManager *pm)
{
GtkWidget *menu;
GtkWidget *item;
GtkWidget *image;
EomPluginInfo *info;
info = plugin_manager_get_selected_plugin (pm);
if (info == NULL)
return NULL;
menu = gtk_menu_new ();
item = gtk_image_menu_item_new_with_mnemonic (_("_About"));
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (about_button_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_image_menu_item_new_with_mnemonic (_("C_onfigure"));
image = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (configure_button_cb), pm);
gtk_widget_set_sensitive (item,
eom_plugin_engine_plugin_is_configurable (info));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_check_menu_item_new_with_mnemonic (_("A_ctivate"));
gtk_widget_set_sensitive (item,
eom_plugin_engine_plugin_is_available (info));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
eom_plugin_engine_plugin_is_active (info));
g_signal_connect (item, "toggled",
G_CALLBACK (enable_plugin_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_mnemonic (_("Ac_tivate All"));
g_signal_connect (item, "activate",
G_CALLBACK (enable_all_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_mnemonic (_("_Deactivate All"));
g_signal_connect (item, "activate",
G_CALLBACK (disable_all_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (menu);
return menu;
}
//set up the popup menu, if enabled
void set_menu(){
//TODO: add stock icons
if (settings.enable_tray_menu){
GtkWidget *exit_entry = gtk_image_menu_item_new_with_mnemonic(_("_Exit"));
GtkWidget *config_entry = gtk_image_menu_item_new_with_mnemonic(_("_Config Window"));
GtkWidget *show_entry = gtk_image_menu_item_new_with_mnemonic(_("_Full Window"));
GtkWidget *exit_icon = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
GtkWidget *config_icon = gtk_image_new_from_stock(GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU);
GtkWidget *show_icon = gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(exit_entry), exit_icon);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(config_entry), config_icon);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(show_entry), show_icon);
g_signal_connect(G_OBJECT(exit_entry), "activate", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(config_entry), "activate", G_CALLBACK(configure), NULL);
g_signal_connect(G_OBJECT(show_entry), "activate", G_CALLBACK(open_window), NULL);
if (G_IS_OBJECT(settings.tray_icon_menu)){
gtk_widget_destroy(settings.tray_icon_menu);
}
settings.tray_icon_menu = gtk_menu_new();
//Decide which order to stack the menu, so that the entry under the mouse
//initially will hopefully be show_entry, which is what the user is most
//likely trying to use, as opposed to exit_entry, which they probably do
//not want to accidentally hit...
GdkScreen *screen = gdk_screen_get_default();
int icon_x,icon_y;
#if GTK_CHECK_VERSION(2,16,0)
GdkScreen *screen_from_tray;
GdkRectangle area;
GtkOrientation orientation;
if (gtk_status_icon_get_geometry(settings.tray_icon, &screen_from_tray, &area, &orientation)){
icon_x = area.x;
icon_y = area.y;
} else {
icon_x = gdk_screen_get_width(screen);
icon_y = gdk_screen_get_height(screen);
}
#else
gtk_window_get_position(GTK_WINDOW(settings.tray_icon), &icon_x, &icon_y);
#endif
if (icon_y > gdk_screen_get_height(screen)/2){
//taskbar is on bottom, so put show_entry on bottom for ergonomics
tray_at_bottom = true;
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), exit_entry);
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), config_entry);
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), show_entry);
} else {
//taskbar is on top, so put show_entry on top for ergonomics
tray_at_bottom = false;
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), show_entry);
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), config_entry);
gtk_menu_shell_append(GTK_MENU_SHELL(settings.tray_icon_menu), exit_entry);
}
//make menu potentially visible
gtk_widget_show_all(settings.tray_icon_menu);
}
}
static gboolean
handle_button_press (GtkWidget *widget, GdkEventButton *event)
{
GtkWidget *item;
SeahorseApplet *applet = SEAHORSE_APPLET (widget);
SeahorseAppletPrivate *priv = SEAHORSE_APPLET_GET_PRIVATE (applet);
if (event->button == 1) {
if (priv->menu) {
gtk_widget_destroy (priv->menu);
priv->menu = NULL;
}
/* Build Menu */
priv->menu = gtk_menu_new ();
if (priv->clipboard_contents == SEAHORSE_TEXT_TYPE_PLAIN ||
priv->clipboard_contents == SEAHORSE_TEXT_TYPE_NONE) {
item = gtk_image_menu_item_new_with_mnemonic (_("_Encrypt Clipboard"));
g_signal_connect (item, "activate", G_CALLBACK (encrypt_cb), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
}
if (priv->clipboard_contents == SEAHORSE_TEXT_TYPE_PLAIN ||
priv->clipboard_contents == SEAHORSE_TEXT_TYPE_NONE) {
item = gtk_image_menu_item_new_with_mnemonic (_("_Sign Clipboard"));
g_signal_connect (item, "activate", G_CALLBACK (sign_cb), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
}
if (priv->clipboard_contents == SEAHORSE_TEXT_TYPE_MESSAGE ||
priv->clipboard_contents == SEAHORSE_TEXT_TYPE_SIGNED) {
item = gtk_image_menu_item_new_with_mnemonic (_("_Decrypt/Verify Clipboard"));
g_signal_connect (item, "activate", G_CALLBACK (dvi_cb), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
}
if (priv->clipboard_contents == SEAHORSE_TEXT_TYPE_KEY) {
item = gtk_image_menu_item_new_with_mnemonic (_("_Import Keys from Clipboard"));
g_signal_connect (item, "activate", G_CALLBACK (dvi_cb), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), item);
}
gtk_widget_show_all (priv->menu);
gtk_menu_popup (GTK_MENU (priv->menu), NULL, NULL, seahorse_popup_position_menu,
(gpointer)applet, event->button, event->time);
return TRUE;
}
if (GTK_WIDGET_CLASS (seahorse_applet_parent_class)->button_press_event)
return (* GTK_WIDGET_CLASS (seahorse_applet_parent_class)->button_press_event) (widget, event);
return FALSE;
}
static void
panel_context_menu_build_edition (PanelWidget *panel_widget,
GtkWidget *menu)
{
GtkWidget *menuitem;
GtkWidget *image;
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Add to Panel..."));
image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (G_OBJECT (menuitem), "activate",
G_CALLBACK (panel_addto_present), panel_widget);
if (!panel_profile_id_lists_are_writable ())
gtk_widget_set_sensitive (menuitem, FALSE);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Properties"));
image = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect_swapped (menuitem, "activate",
G_CALLBACK (panel_properties_dialog_present),
panel_widget->toplevel);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Delete This Panel"));
image = gtk_image_new_from_stock (GTK_STOCK_DELETE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect_swapped (G_OBJECT (menuitem), "activate",
G_CALLBACK (panel_context_menu_delete_panel),
panel_widget->toplevel);
g_signal_connect (G_OBJECT (menu), "show",
G_CALLBACK (panel_context_menu_setup_delete_panel_item),
menuitem);
add_menu_separator (menu);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_New Panel"));
image = gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (panel_context_menu_create_new_panel),
NULL);
gtk_widget_set_sensitive (menuitem,
panel_profile_id_lists_are_writable ());
add_menu_separator (menu);
}
GtkWidget *
panel_context_menu_create (PanelWidget *panel)
{
GtkWidget *retval;
GtkWidget *menuitem;
GtkWidget *image;
if (panel->master_widget) {
gpointer *pointer;
AppletInfo *info;
pointer = g_object_get_data (G_OBJECT (panel->master_widget),
"applet_info");
g_assert (pointer != NULL);
info = (AppletInfo *) pointer;
if (info->menu == NULL) {
info->menu = mate_panel_applet_create_menu (info);
}
return info->menu;
}
retval = create_empty_menu ();
gtk_widget_set_name (retval, "mate-panel-context-menu");
if (!panel_lockdown_get_locked_down ())
panel_context_menu_build_edition (panel, retval);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Help"));
image = gtk_image_new_from_stock (GTK_STOCK_HELP, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (panel_context_menu_show_help), NULL);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("A_bout Panels"));
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (panel_context_menu_show_about_dialog),
NULL);
//FIXME: can we get rid of this? (needed by menu_get_panel())
g_object_set_data (G_OBJECT (retval), "menu_panel", panel);
return retval;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE label, use_underline_or_accel_group;
GtkWidget *widget = NULL;
if (rb_scan_args(argc, argv, "02", &label, &use_underline_or_accel_group) > 0) {
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline_or_accel_group) || RVAL2CBOOL(use_underline_or_accel_group)){
widget = gtk_image_menu_item_new_with_mnemonic(RVAL2CSTR(label));
} else {
widget = gtk_image_menu_item_new_with_label(RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_image_menu_item_new_from_stock(rb_id2name(SYM2ID(label)),
NIL_P(use_underline_or_accel_group) ? NULL :
GTK_ACCEL_GROUP(RVAL2GOBJ(use_underline_or_accel_group)));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
} else {
widget = gtk_image_menu_item_new();
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
GtkWidget *
gul_gui_append_new_menuitem_stock_icon (GtkWidget *menu,
const char *stock_id,
const char *mnemonic,
GCallback callback,
gpointer data)
{
GtkWidget *menu_item;
GtkWidget *image;
menu_item = gtk_image_menu_item_new_with_mnemonic (mnemonic);
image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
menu_item);
if (callback)
{
g_signal_connect (G_OBJECT (menu_item),
"activate",
callback, data);
}
return menu_item;
}
GtkWidget *
empathy_contact_log_menu_item_new (EmpathyContact *contact)
{
EmpathyLogManager *manager;
gboolean have_log;
GtkWidget *item;
GtkWidget *image;
g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
manager = empathy_log_manager_new ();
have_log = empathy_log_manager_exists (manager,
empathy_contact_get_account (contact),
empathy_contact_get_id (contact),
FALSE);
g_object_unref (manager);
item = gtk_image_menu_item_new_with_mnemonic (_("_View Previous Conversations"));
image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_widget_set_sensitive (item, have_log);
gtk_widget_show (image);
g_signal_connect_swapped (item, "activate",
G_CALLBACK (contact_log_menu_item_activate_cb),
contact);
return item;
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
if (GTK_IS_LABEL (button->priv->label_widget))
{
label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
}
else if (button->priv->label_text)
{
label = button->priv->label_text;
use_mnemonic = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (GTK_IS_IMAGE (button->priv->icon_widget))
{
menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
gtk_widget_get_settings (GTK_WIDGET (button)));
}
else if (button->priv->stock_id)
{
menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
void cgraphics_menu_new_item( widget_t *widget, list_item_t *item )
{
GtkMenuShell *ps = cgraphics_menubar_get_native_parent( widget, item );
GtkMenuItem *mi;
if ( item->data[1] == 0 )
mi = GTK_MENU_ITEM(gtk_separator_menu_item_new());
else
{
char *txt = item->data[1];
int a;
// fix up mnemonics.. GTK expects _, not &.
for ( a = 0; a < strlen( txt ); a++ )
if ( txt[a] == '&' )
txt[a] = '_';
mi = GTK_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic( item->data[1]));
g_signal_connect( G_OBJECT(mi), "activate", G_CALLBACK(cgraphics_menu_item_pushed_handler), item );
if ( item->data[0] != 0 )
{
image_t *im = (image_t *)item->data[0];
GtkImage *mim = GTK_IMAGE(gtk_image_new_from_pixbuf( NULL));
gtk_image_set_from_pixbuf( mim, (GdkPixbuf *)im->native );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(mi), GTK_WIDGET(mim) );
gtk_widget_show( GTK_WIDGET(mim) );
}
}
item->nativeid = (size_t)mi;
gtk_menu_shell_insert( ps, GTK_WIDGET(mi), item->row );
gtk_widget_show(GTK_WIDGET(mi));
}
void
MenuBuilderGtk::add_action (const std::string icon,
const std::string label,
const boost::function0<void> callback)
{
GtkWidget *item = NULL;
GtkWidget *image = NULL;
const std::string gtk_icon = convert_icon_to_gtk (icon);
Action *action = new Action (callback);
nbr_elements++;
last_was_separator = false;
item = gtk_image_menu_item_new_with_mnemonic (label.c_str ());
image = gtk_image_new_from_icon_name (gtk_icon.c_str (), GTK_ICON_SIZE_MENU);
if (image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_object_set_data_full (G_OBJECT (item),
"menu-builder-gtk-action",
(gpointer)action, delete_action_with_item);
g_signal_connect (item, "activate",
G_CALLBACK (on_item_activate), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
GtkMenuItem* ContextMenuItem::createNativeMenuItem(const PlatformMenuItemDescription& menu)
{
GtkMenuItem* item = 0;
if (menu.type == SeparatorType)
item = GTK_MENU_ITEM(gtk_separator_menu_item_new());
else {
if (menu.type == CheckableActionType) {
item = GTK_MENU_ITEM(gtk_check_menu_item_new_with_mnemonic(menu.title.utf8().data()));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), menu.checked);
} else {
if (const gchar* stockID = gtkStockIDFromContextMenuAction(menu.action)) {
item = GTK_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic(menu.title.utf8().data()));
GtkWidget* image = gtk_image_new_from_stock(stockID, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
} else
item = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic(menu.title.utf8().data()));
}
ContextMenuAction* menuAction = static_cast<ContextMenuAction*>(malloc(sizeof(ContextMenuAction*)));
*menuAction = menu.action;
g_object_set_data(G_OBJECT(item), WEBKIT_CONTEXT_MENU_ACTION, menuAction);
gtk_widget_set_sensitive(GTK_WIDGET(item), menu.enabled);
if (menu.subMenu)
gtk_menu_item_set_submenu(item, GTK_WIDGET(menu.subMenu));
}
return item;
}
int
clip_GTK_IMAGEMENUITEMNEWWITHMNEMONIC(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm, 1);
gchar *label = _clip_parc(cm, 2);
C_widget *cimage ;
GtkWidget *image ;
CHECKOPT(1,MAP_t);
CHECKARG(2, CHARACTER_t);
LOCALE_TO_UTF(label);
image = gtk_image_menu_item_new_with_mnemonic(label);
if (image)
{
cimage = _list_get_cwidget(cm, image);
if (!cimage) cimage = _register_widget(cm, image, cv);
if (cimage) _clip_mclone(cm, RETPTR(cm), &cimage->obj);
}
FREE_TEXT(label);
return 0;
err:
return 1;
}
static GtkWidget *
menu_add_item (GtkMenuShell *menu,
const gchar *mnemonic,
const gchar *tooltip,
const gchar *stock_image,
GCallback activate_handler,
gpointer activate_data)
{
GtkWidget *item;
if (! stock_image) {
item = gtk_menu_item_new_with_mnemonic (mnemonic);
} else {
item = gtk_image_menu_item_new_with_mnemonic (mnemonic);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_stock (stock_image,
GTK_ICON_SIZE_MENU));
}
gtk_widget_set_tooltip_text (item, tooltip);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
if (activate_handler) {
g_signal_connect (item, "activate", activate_handler, activate_data);
}
return item;
}
void DockLet::PopupMenu(GdkEventButton *event)
{
if (!menu) {
menu = gtk_menu_new();
scan_menuitem = gtk_check_menu_item_new_with_mnemonic(_("_Scan"));
g_signal_connect(G_OBJECT(scan_menuitem), "toggled", G_CALLBACK(MenuScanCallback), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), scan_menuitem);
GtkWidget *menuitem;
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Quit"));
GtkWidget *image;
image = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(MenuQuitCallback), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
}
bool scan_selection=conf->get_bool("/apps/stardict/preferences/dictionary/scan_selection");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(scan_menuitem),
scan_selection);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time);
}
static GtkWidget* unicodeMenuItem(WebKitWebView* webView)
{
if (gtk_major_version > 2 || (gtk_major_version == 2 && gtk_minor_version >= 10)) {
GtkSettings* settings = webView ? gtk_widget_get_settings(GTK_WIDGET(webView)) : gtk_settings_get_default();
gboolean showMenu = TRUE;
if (settings)
g_object_get(settings, "gtk-show-unicode-menu", &showMenu, NULL);
if (!showMenu)
return 0;
}
GtkWidget* menuitem = gtk_image_menu_item_new_with_mnemonic(
_("_Insert Unicode Control Character"));
GtkWidget* unicodeContextMenu = gtk_menu_new();
unsigned i;
for (i = 0; i < G_N_ELEMENTS(bidi_menu_entries); i++) {
GtkWidget* menuitem = gtk_menu_item_new_with_mnemonic(_(bidi_menu_entries[i].label));
g_object_set_data(G_OBJECT(menuitem), "gtk-unicode-menu-entry", (gpointer)&bidi_menu_entries[i]);
g_signal_connect(menuitem, "activate", G_CALLBACK(insertControlCharacter), 0);
gtk_widget_show(menuitem);
gtk_menu_shell_append(GTK_MENU_SHELL(unicodeContextMenu), menuitem);
// FIXME: Make the item sensitive as insertControlCharacter() is implemented
gtk_widget_set_sensitive(menuitem, FALSE);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), unicodeContextMenu);
return menuitem;
}
/* Generate a menu */
static GtkWidget *
menu_generate ( MAINWIN * c )
{
GtkWidget * menu = gtk_menu_new();
GtkWidget * item;
gint i;
for( i = 0; i < sizeof(Menu) / sizeof(struct MenuSpec); i++ )
{
if( !Menu[i].name && !Menu[i].handler )
item = gtk_separator_menu_item_new();
else
if( Menu[i].image )
item = gzrt_gtk_image_menu_item_stock( Menu[i].image, GTK_ICON_SIZE_MENU, Menu[i].name );
else
item = gtk_image_menu_item_new_with_mnemonic( Menu[i].name );
if( Menu[i].handler )
g_signal_connect_swapped( G_OBJECT(item), "activate", G_CALLBACK(Menu[i].handler), c );
gtk_menu_shell_append( GTK_MENU_SHELL(menu), item );
}
gtk_widget_show_all( menu );
return menu;
}
GtkWidget *
gu_menu_add_item(GtkWidget *parent, const char *title,
void (*cb)(GtkWidget *menuitem, gpointer aux),
gpointer aux, const char *image, const char *accel,
gboolean sensitive)
{
GtkWidget *w;
GtkWidget *img;
if(image != NULL) {
w = gtk_image_menu_item_new_with_mnemonic(title);
img = gtk_image_new_from_stock(image, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(w), img);
} else {
w = gtk_menu_item_new_with_mnemonic(title);
}
if(accel != NULL) {
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(w), accel);
}
gtk_widget_set_sensitive(w, sensitive);
gtk_menu_shell_append(GTK_MENU_SHELL(parent), w);
g_signal_connect(G_OBJECT(w), "activate", (void *)cb, aux);
return w;
}
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 GtkWidget* ink_action_create_menu_item( GtkAction* action )
{
InkAction* act = INK_ACTION( action );
GtkWidget* item = 0;
if ( act->private_data->iconId ) {
gchar* label = 0;
g_object_get( G_OBJECT(act), "label", &label, NULL );
item = gtk_image_menu_item_new_with_mnemonic( label );
GtkWidget* child = sp_icon_new( Inkscape::ICON_SIZE_MENU, act->private_data->iconId );
// TODO this work-around is until SPIcon will live properly inside of a popup menu
if ( SP_IS_ICON(child) ) {
SPIcon* icon = SP_ICON(child);
sp_icon_fetch_pixbuf( icon );
GdkPixbuf* target = icon->pb;
if ( target ) {
child = gtk_image_new_from_pixbuf( target );
gtk_widget_set_sensitive(child, gtk_action_is_sensitive(action));
gtk_widget_destroy( GTK_WIDGET(icon) );
}
}
gtk_widget_show_all( child );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(item), child );
g_free( label );
label = 0;
} else {
item = GTK_ACTION_CLASS(ink_action_parent_class)->create_menu_item( action );
}
return item;
}
static void
build_menu (NemoBlankDesktopWindow *window)
{
if (window->details->popup_menu) {
return;
}
NemoActionManager *desktop_action_manager = nemo_desktop_manager_get_action_manager ();
if (window->details->actions_changed_id == 0) {
window->details->actions_changed_id = g_signal_connect_swapped (desktop_action_manager,
"changed",
G_CALLBACK (actions_changed_cb),
window);
}
GList *action_list = nemo_action_manager_list_actions (desktop_action_manager);
if (g_list_length (action_list) == 0)
return;
window->details->popup_menu = gtk_menu_new ();
gboolean show;
g_object_get (gtk_settings_get_default (), "gtk-menu-images", &show, NULL);
gtk_menu_attach_to_widget (GTK_MENU (window->details->popup_menu),
GTK_WIDGET (window),
NULL);
GtkWidget *item;
GList *l;
NemoAction *action;
for (l = action_list; l != NULL; l = l->next) {
action = l->data;
if (action->show_in_blank_desktop && action->dbus_satisfied) {
gchar *label = nemo_action_get_label (action, NULL, NULL);
item = gtk_image_menu_item_new_with_mnemonic (label);
g_free (label);
const gchar *stock_id = gtk_action_get_stock_id (GTK_ACTION (action));
const gchar *icon_name = gtk_action_get_icon_name (GTK_ACTION (action));
if (stock_id || icon_name) {
GtkWidget *image = stock_id ? gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU) :
gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), show);
}
gtk_widget_set_visible (item, TRUE);
g_signal_connect (item, "activate", G_CALLBACK (action_activated_callback), action);
gtk_menu_shell_append (GTK_MENU_SHELL (window->details->popup_menu), item);
}
}
}
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 add_copy_menu_item ( GtkMenu *menu, GtkWidget *tree_view )
{
GtkWidget *item = gtk_image_menu_item_new_with_mnemonic ( _("_Copy Data") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_selected), tree_view );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
}
/* Called when the tray icon is right->clicked
* Displays the menu. */
void trayicon_on_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
{
START_FUNC
GtkWidget *menu, *about, *config, *quit;
#ifdef ENABLE_HELP
GtkWidget *help;
#endif
struct trayicon *trayicon=(struct trayicon *)(user_data);
menu=gtk_menu_new();
quit=gtk_image_menu_item_new_with_mnemonic(_("_Quit"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(quit),
gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU));
g_signal_connect_swapped(quit, "activate", trayicon->trayicon_quit, NULL);
#ifdef ENABLE_HELP
help=gtk_image_menu_item_new_with_mnemonic(_("_Help"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(help),
gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_MENU));
g_signal_connect(help, "activate", G_CALLBACK(trayicon_help), NULL);
#endif
about=gtk_image_menu_item_new_with_mnemonic(_("_About"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(about),
gtk_image_new_from_stock(GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU));
g_signal_connect(about, "activate", G_CALLBACK(trayicon_about), NULL);
config=gtk_image_menu_item_new_with_mnemonic(_("_Preferences"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(config),
gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU));
g_signal_connect(config, "activate", G_CALLBACK(settings), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), config);
#ifdef ENABLE_HELP
gtk_menu_shell_append(GTK_MENU_SHELL(menu), help);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu), about);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit);
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, gtk_status_icon_position_menu,
status_icon, button, activate_time);
END_FUNC
}
/* Generate plugins menu item */
GtkWidget * gzrt_plugins_menu ( void )
{
GtkWidget * menu_head;
GtkWidget * menu;
GtkWidget * item;
PLUGINS * p = &plugins;
static int init;
/* Create title object */
menu_head = gtk_menu_item_new_with_mnemonic( "_Plugins" );
/* Create menu object */
menu = gtk_menu_new();
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_head), menu );
/* Create each respective plugin's entry */
if( plugins.dl )
while( p )
{
/* Create menu entry */
item = gtk_image_menu_item_new_with_mnemonic( p->meta->long_name );
/* Add it to menu */
gtk_container_add( GTK_CONTAINER(menu), item );
/* Set handler */
if( p->meta->menu_bar )
g_signal_connect_swapped( G_OBJECT(item), "activate", G_CALLBACK(p->meta->menu_bar), NULL );
/* Call the functions init function (if applicable) */
if( !init && p->meta->init )
p->meta->init( &functions );
/* Seek to next */
p = p->next;
}
/* Create menu seperator
sep = gtk_separator_menu_item_new();
gtk_container_add( GTK_CONTAINER(menu), sep );*/
/* Create plugin preferences entry
item = gtk_menu_item_new_with_mnemonic( "Preferences" );
g_signal_connect_swapped( G_OBJECT(item), "activate", G_CALLBACK(gzrt_plugins_preferences), NULL );
gtk_container_add( GTK_CONTAINER(menu), item );*/
/* Initialized */
init++;
/* Show all */
gtk_widget_show_all( menu );
/* No plugins? */
gtk_widget_set_sensitive( menu_head, (plugins.dl ? TRUE : FALSE) );
/* Return final product */
return menu_head;
}
/* Creates a new GtkImageMenuItem with a stock image and a custom label.*/
GtkWidget *gtk_menu_item_new_image_item(const gchar *stock_id, const gchar *label)
{
GtkWidget *item = gtk_image_menu_item_new_with_mnemonic(label);
GtkWidget *image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(image);
return item;
}
static gboolean add_menu_items ( GtkMenu *menu, VikTrwLayer *vtl, VikWaypoint *wpt, gpointer wpt_uuid, VikViewport *vvp, GtkWidget *tree_view, gpointer data )
{
static menu_array_values values;
GtkWidget *item;
values[MA_VTL] = vtl;
values[MA_WPT] = wpt;
values[MA_WPT_UUID] = wpt_uuid;
values[MA_VVP] = vvp;
values[MA_TREEVIEW] = tree_view;
values[MA_WPTS_LIST] = data;
/*
item = gtk_image_menu_item_new_with_mnemonic ( _("_Select") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_select), values );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
*/
// AUTO SELECT NOT TRUE YET...
// ATM view auto selects, so don't bother with separate select menu entry
item = gtk_image_menu_item_new_with_mnemonic ( _("_View") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_view), values );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_properties), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Show Picture...") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-Show Picture", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_show_picture), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
gtk_widget_set_sensitive ( item, GPOINTER_TO_INT(wpt->image) );
add_copy_menu_item ( menu, tree_view );
return TRUE;
}
