static void
cb_gimmix_covers_plugin_plc_popup (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
GtkWidget *menu = NULL;
GtkWidget *menu_item = NULL;
GtkWidget *image = NULL;
if (event->button == 3) /* If right click */
{
menu = gtk_menu_new ();
image = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_MENU);
menu_item = gtk_image_menu_item_new_with_label (_("Set cover from file"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item), image);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK (cb_gimmix_covers_plugin_set_cover_from_file), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
image = gtk_image_new_from_stock ("gtk-refresh", GTK_ICON_SIZE_MENU);
menu_item = gtk_image_menu_item_new_with_label (_("Re-fetch cover"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item), image);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(cb_gimmix_covers_plugin_refetch_cover), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
gtk_widget_show (menu);
gtk_menu_popup (GTK_MENU(menu),
NULL,
NULL,
NULL,
NULL,
3,
gtk_get_current_event_time());
}
}
static void remmina_ftp_client_popup_menu(RemminaFTPClient *client, GdkEventButton *event)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *image;
menu = gtk_menu_new();
menuitem = gtk_image_menu_item_new_with_label(_("Download"));
gtk_widget_show(menuitem);
image = gtk_image_new_from_icon_name("document-save", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_download), client);
menuitem = gtk_image_menu_item_new_with_label(_("Upload"));
gtk_widget_show(menuitem);
image = gtk_image_new_from_icon_name("document-send", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_upload), client);
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
gtk_widget_show(menuitem);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_delete), client);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time);
}
static GObject *constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) {
GObject *obj;
PyraconfigWindow *window;
PyraconfigWindowPrivate *priv;
RoccatConfigWindow *roccat_window;
PyraRMP *rmp;
guint i;
GtkMenuItem *menu_item;
GtkWidget *profile_page;
obj = G_OBJECT_CLASS(pyraconfig_window_parent_class)->constructor(gtype, n_properties, properties);
window = PYRACONFIG_WINDOW(obj);
priv = window->priv;
roccat_window = ROCCAT_CONFIG_WINDOW(obj);
priv->config = pyra_configuration_load();
for (i = 0; i < PYRA_PROFILE_NUM; ++i) {
profile_page = pyraconfig_profile_page_new();
roccat_config_window_append_page(roccat_window, ROCCAT_PROFILE_PAGE(profile_page));
rmp = pyra_rmp_load_actual(i);
pyraconfig_profile_page_set_rmp(PYRACONFIG_PROFILE_PAGE(profile_page), rmp);
pyra_rmp_free(rmp);
g_signal_connect(G_OBJECT(profile_page), "load-from-file", G_CALLBACK(load_profile_from_file_cb), window);
g_signal_connect(G_OBJECT(profile_page), "save-to-file", G_CALLBACK(save_profile_to_file_cb), window);
}
menu_item = GTK_MENU_ITEM(gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL));
g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(menu_edit_preferences_cb), window);
roccat_config_window_edit_menu_append(roccat_window, menu_item);
menu_item = GTK_MENU_ITEM(gtk_image_menu_item_new_with_label(_("Reset")));
g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(menu_device_reset_cb), window);
roccat_config_window_device_menu_append(roccat_window, menu_item);
menu_item = GTK_MENU_ITEM(gtk_image_menu_item_new_with_label(_("Info")));
g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(menu_device_info_cb), window);
roccat_config_window_device_menu_append(roccat_window, menu_item);
g_signal_connect(G_OBJECT(roccat_window), "active-changed", G_CALLBACK(window_active_page_changed_cb), NULL);
g_signal_connect(G_OBJECT(roccat_window), "delete-event", G_CALLBACK(delete_event_cb), NULL);
g_signal_connect(G_OBJECT(roccat_window), "save-all", G_CALLBACK(save_all_cb), NULL);
g_signal_connect(G_OBJECT(roccat_window), "device-added", G_CALLBACK(device_add_cb), NULL);
g_signal_connect(G_OBJECT(roccat_window), "device-removed", G_CALLBACK(device_remove_cb), NULL);
/* keep this order */
priv->dbus_proxy = pyra_dbus_proxy_new();
roccat_config_window_set_device_scanner(roccat_window, ROCCAT_DEVICE_SCANNER_INTERFACE(pyra_device_scanner_new()));
gtk_widget_show(GTK_WIDGET(window));
/* if a device is already plugged in, add_cb has already been executed */
roccat_config_window_warn_if_no_device(roccat_window);
return obj;
}
// 构造GUI函数。
// 输入：void
// 返回值：void
void construct_GUI()
{
background = gdk_pixbuf_new_from_file("res/background.jpg",NULL);
A_pic = gdk_pixbuf_new_from_file("res/A.png",NULL);
B_pic = gdk_pixbuf_new_from_file("res/B.png",NULL);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(main_window,627,570);
gtk_window_set_resizable(GTK_WINDOW(main_window),FALSE);
gtk_window_set_title(GTK_WINDOW(main_window),("Tic Tac toe"));
g_signal_connect(G_OBJECT(main_window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * layout = gtk_layout_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(main_window),layout);
GtkWidget * menubar = gtk_menu_bar_new();
GtkWidget * menu1 = gtk_menu_new();
GtkWidget * option = gtk_menu_item_new_with_mnemonic("option");
GtkWidget * player = gtk_image_menu_item_new_with_label("player first");
GtkWidget * computer = gtk_image_menu_item_new_with_label("computer first");
GtkWidget * sep = gtk_separator_menu_item_new();
g_signal_connect(G_OBJECT(player),"activate",G_CALLBACK(player_first),NULL);
g_signal_connect(G_OBJECT(computer),"activate",G_CALLBACK(computer_first),NULL);
GtkWidget * quit = gtk_image_menu_item_new_with_label("quit");
g_signal_connect(G_OBJECT(quit),"activate",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * menu2 = gtk_menu_new();
GtkWidget * help = gtk_menu_item_new_with_mnemonic("help");
GtkWidget * about = gtk_image_menu_item_new_with_label("about..");
g_signal_connect(G_OBJECT(about),"activate",G_CALLBACK(about_pressed),NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(option),menu1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),player);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),computer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),quit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help),menu2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu2),about);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),option);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),help);
gtk_layout_put(GTK_LAYOUT(layout),menubar,0,0);
gtk_widget_set_size_request(menubar,627,20);
draw_window = gtk_drawing_area_new();
gtk_layout_put(GTK_LAYOUT(layout),draw_window,0,20);
gtk_widget_set_size_request(draw_window,627,570);
g_signal_connect(draw_window,"expose-event",G_CALLBACK(window_drawing),NULL);
gtk_widget_set_events(draw_window,gtk_widget_get_events(draw_window)|GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(draw_window),"button-press-event",G_CALLBACK(when_key_pressed),NULL);
gtk_widget_show_all(main_window);
}
GtkWidget*
fm__make_context_menu()
{
GtkWidget* menu = gtk_menu_new();
//show the current directory name
//FIXME initially the dir path is not set. We need to set it in a callback.
AyyiFilemanager* fm = file_manager__get();
const char* name = fm->real_path ? fm->real_path : "Directory";
GtkWidget* title = gtk_menu_item_new_with_label(name);
gtk_container_add(GTK_CONTAINER(menu), title);
menu_separator_new(menu);
GtkWidget* parent = menu;
GtkWidget* a = NULL;
int i; for(i=0;i<G_N_ELEMENTS(fm_menu_def);i++){
MenuDef* item = &fm_menu_def[i];
switch(item->label[0]){
case '-':
menu_separator_new(menu);
break;
case '<':
gtk_menu_item_set_submenu(GTK_MENU_ITEM(a), parent);
parent = menu;
break;
case '>':
item = &fm_menu_def[++i]; // following item must be the submenu parent item.
parent = gtk_menu_new();
GtkWidget* sub = a = gtk_image_menu_item_new_with_label(item->label);
//GtkWidget* ico = gtk_image_new_from_pixbuf(mime_type_get_pixbuf(inode_directory)); // TODO *****
//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(sub), ico);
if(item->stock_id){
fm_menu__item_image_from_stock(menu, a, item->stock_id);
}
gtk_container_add(GTK_CONTAINER(menu), sub);
break;
default:
;GtkWidget* menu_item = gtk_image_menu_item_new_with_label (item->label);
gtk_menu_shell_append (GTK_MENU_SHELL(parent), menu_item);
if(item->stock_id){
fm_menu__item_image_from_stock(menu, menu_item, item->stock_id);
}
if(item->callback) g_signal_connect (G_OBJECT(menu_item), "activate", G_CALLBACK(item->callback), GINT_TO_POINTER(item->callback_data));
}
}
fm__menu_on_view_change(menu);
g_signal_connect(file_manager__get(), "dir_changed", G_CALLBACK(menu_on_dir_changed), title);
gtk_widget_show_all(menu);
return menu;
}
static void
xmr_indicator_plugin_init(XmrIndicatorPlugin *plugin)
{
GtkWidget *item;
plugin->settings = g_settings_new("com.timxx.xmradio.plugins.indicator");
plugin->hide_on_exit = g_settings_get_boolean(plugin->settings, "hide-on-exit");
plugin->indicator = NULL;
plugin->popup_menu = gtk_menu_new();
item = gtk_image_menu_item_new_with_label(_("Show"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PLAY, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
plugin->menu_item_play = item;
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
plugin->menu_item_pause = item;
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_NEXT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(item), TRUE);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_with_label(_("Love"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_image_menu_item_new_with_label(_("Hate"));
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(plugin->popup_menu), item);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), plugin);
gtk_widget_show_all(plugin->popup_menu);
}
static GtkWidget *linphone_gtk_create_call_log_menu(GtkWidget *call_log){
GtkWidget *menu=gtk_menu_new();
GtkWidget *menu_item;
gchar *call_label=NULL;
gchar *text_label=NULL;
gchar *name=NULL;
GtkWidget *image;
GtkTreeSelection *select;
GtkTreeIter iter;
select=gtk_tree_view_get_selection(GTK_TREE_VIEW(call_log));
if (select!=NULL){
GtkTreeModel *model=NULL;
if (gtk_tree_selection_get_selected (select,&model,&iter)){
gpointer pcl;
LinphoneAddress *la;
LinphoneCallLog *cl;
gtk_tree_model_get(model,&iter,2,&pcl,-1);
cl = (LinphoneCallLog *)pcl;
la = linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl);
name=linphone_address_as_string(la);
call_label=g_strdup_printf(_("Call %s"),name);
text_label=g_strdup_printf(_("Send text to %s"),name);
g_free(name);
}
}
if (call_label){
menu_item=gtk_image_menu_item_new_with_label(call_label);
image=gtk_image_new_from_stock(GTK_STOCK_NETWORK,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
gtk_widget_show(image);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_selected,call_log);
}
if (text_label){
menu_item=gtk_image_menu_item_new_with_label(text_label);
image=gtk_image_new_from_stock(GTK_STOCK_NETWORK,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
gtk_widget_show(image);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_chat_selected,call_log);
}
menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_add_contact,call_log);
gtk_widget_show(menu);
gtk_menu_attach_to_widget(GTK_MENU(menu),call_log, NULL);
if (call_label) g_free(call_label);
if (text_label) g_free(text_label);
return menu;
}
static void *process_menu_item(struct menu_item *item, void *arg) {
GtkMenu *menu = GTK_MENU(arg);
GtkWidget *mitem;
GtkWidget *submenu;
GtkWidget *image;
GtkWidget *separator;
void *result = NULL;
switch (item->type) {
case MENU:
submenu = gtk_menu_new();
result = submenu;
break;
case MENUEND:
submenu = item->prevarg;
if (item->children) {
mitem = gtk_image_menu_item_new_with_label(item->name);
image = get_image(item->icon);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), image);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mitem);
gtk_widget_show(submenu);
gtk_widget_show(mitem);
} else {
gtk_widget_destroy(submenu);
}
break;
case SEPARATOR:
separator = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), separator);
gtk_widget_show(separator);
break;
case ENTRY:
mitem = gtk_image_menu_item_new_with_label(item->name);
image = get_image(item->icon);
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), image);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mitem);
g_signal_connect (G_OBJECT(mitem), "activate", G_CALLBACK (launcher_activated), g_strdup (item->command));
gtk_widget_show(mitem);
break;
default:
break;
}
return result;
}
static GtkMenu *
create_status_menu (void)
{
GtkMenu *popup_menu = GTK_MENU (gtk_menu_new ());
int i = 0;
GtkMenu *groups_menu = GTK_MENU (gtk_menu_new ());
gchar **current_name = gkbd_status_get_group_names ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (_("_Layouts"));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
GTK_WIDGET (groups_menu));
item = gtk_menu_item_new_with_mnemonic (_("Show _Keyboard Layout..."));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_show_layout, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
/* translators note:
* This is the name of the sagarmatha-settings "region" panel */
item = gtk_menu_item_new_with_mnemonic (_("Region and Language Settings"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_launch_capplet, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
for (i = 0; current_name && *current_name; i++, current_name++) {
gchar *image_file = gkbd_status_get_image_filename (i);
if (image_file == NULL) {
item =
gtk_menu_item_new_with_label (*current_name);
} else {
GdkPixbuf *pixbuf =
gdk_pixbuf_new_from_file_at_size (image_file,
24, 24,
NULL);
GtkWidget *img =
gtk_image_new_from_pixbuf (pixbuf);
item =
gtk_image_menu_item_new_with_label
(*current_name);
gtk_widget_show (img);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM
(item), img);
gtk_image_menu_item_set_always_show_image
(GTK_IMAGE_MENU_ITEM (item), TRUE);
g_free (image_file);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (groups_menu), item);
g_signal_connect (item, "activate",
G_CALLBACK (popup_menu_set_group_cb),
GINT_TO_POINTER (i));
}
return popup_menu;
}
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;
}
int
clip_GTK_IMAGEMENUITEMNEWWITHLABEL(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_label(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 void explorer_add_go_item (Explorer *self, GList *node_link)
{
GtkWidget *menu = glade_xml_get_widget(self->xml, "go_menu_menu");
HistoryNode *node = node_link->data;
GtkWidget *item, *image;
gchar* label;
/* Add the timestamp */
label = explorer_strdup_time(&node->timestamp);
item = gtk_image_menu_item_new_with_label(label);
g_free(label);
/* Add the thumbnail */
image = gtk_image_new_from_pixbuf(node->thumbnail);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
/* Set up a callback to activate this node.
* Note that its data is our node_link, not the Explorer.
*/
g_signal_connect(item, "activate", G_CALLBACK(on_go_menu_item), node_link);
/* Add it to the menu */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
}
void create_inmd_switch()
{
menu = gtk_menu_new ();
int i;
for(i=0; i < inmdN; i++) {
if (!inmd[i].cname || !inmd[i].cname[0])
continue;
char tt[64];
sprintf(tt, "%s ctrl-alt-%c", inmd[i].cname, inmd[i].key_ch);
GtkWidget *item = gtk_image_menu_item_new_with_label (tt);
if (inmd[i].icon) {
char fname[512];
get_icon_path(inmd[i].icon, fname);
GtkWidget *img = gtk_image_new_from_file(fname);
if (img)
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), img);
}
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (cb_update_menu_select), GINT_TO_POINTER(i));
gtk_widget_show(item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
}
static void
populate_popup(GtkTextView *textview, GtkMenu *menu, GtkSpell *spell) {
GtkWidget *img, *mi;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(textview);
GtkTextIter start, end;
char *word;
/* we need to figure out if they picked a misspelled word. */
get_cur_word_extents(buffer, &start, &end);
/* 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_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_label("Spelling Suggestions");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
word = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi),
build_suggestion_menu(spell, buffer, word));
g_free(word);
gtk_widget_show_all(mi);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), mi);
}
GtkWidget *create_tray_menu(MITEM *mitems)
{
GtkWidget *menu = gtk_menu_new ();
int i;
for(i=0; mitems[i].cb; i++) {
GtkWidget *item;
if (!mitems[i].name)
continue;
if (mitems[i].stock_id) {
item = gtk_image_menu_item_new_with_label (_(mitems[i].name));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), gtk_image_new_from_stock(mitems[i].stock_id, GTK_ICON_SIZE_MENU));
}
else
if (mitems[i].check_dat) {
item = gtk_check_menu_item_new_with_label (_(mitems[i].name));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), *mitems[i].check_dat);
} else
item = gtk_menu_item_new_with_label (_(mitems[i].name));
mitems[i].handler = g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (mitems[i].cb), NULL);
gtk_widget_show(item);
mitems[i].item = item;
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
return menu;
}
static GtkWidget *
make_colored_menu_item (char const *label, GOColor c)
{
GtkWidget *button;
GdkPixbuf *pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
COLOR_PREVIEW_WIDTH, COLOR_PREVIEW_HEIGHT);
gdk_pixbuf_fill (pixbuf, c);
if (label && 0 == strcmp (label, " ")) {
/* color buttons are created with a label of " " */
button = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER (button),
gtk_image_new_from_pixbuf (pixbuf));
} else {
button = gtk_image_menu_item_new_with_label (label);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (button),
gtk_image_new_from_pixbuf (pixbuf));
}
g_object_unref (pixbuf);
gtk_widget_show_all (button);
g_object_set_data (G_OBJECT (button), "go_color", GINT_TO_POINTER (c));
/* Workaround for bug http://bugzilla.gnome.org/show_bug.cgi?id=585421 */
g_signal_connect (button, "toggle-size-request", G_CALLBACK (cb_menu_item_toggle_size_request), NULL);
return button;
}
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;
}
void transfer_button_clicked(GtkWidget *button, gpointer call_ref) {
GtkWidget *menu_item;
GtkWidget *menu=gtk_menu_new();
LinphoneCall *call=(LinphoneCall*)call_ref;
LinphoneCore *lc=linphone_gtk_get_core();
const MSList *elem=linphone_core_get_calls(lc);
for(; elem!=NULL; elem=elem->next) {
LinphoneCall *other_call=(LinphoneCall*)elem->data;
GtkWidget *call_view=(GtkWidget*)linphone_call_get_user_pointer(other_call);
if (other_call!=call) {
int call_index=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(call_view),"call_index"));
char *remote_uri=linphone_call_get_remote_address_as_string (other_call);
char *text=g_strdup_printf(_("Transfer to call #%i with %s"),call_index,remote_uri);
menu_item=gtk_image_menu_item_new_with_label(text);
ms_free(remote_uri);
g_free(text);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),create_pixmap("status-green.png"));
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_transfer_call,other_call);
}
}
gtk_menu_popup(GTK_MENU(menu),NULL,NULL,NULL,NULL,0,gtk_get_current_event_time());
gtk_widget_show(menu);
}
GtkWidget *
util_image_menu_item(
const gchar * icon_stock_id,
const gchar * label_text,
GCallback activate_cb,
gpointer activate_user_data)
{
GtkWidget * item_w;
if(icon_stock_id) {
item_w = gtk_image_menu_item_new_with_label("");
gtk_image_menu_item_set_image(
GTK_IMAGE_MENU_ITEM(item_w),
gtk_image_new_from_stock(icon_stock_id, GTK_ICON_SIZE_MENU));
} else {
item_w = gtk_menu_item_new_with_label("");
}
gtk_label_set_markup_with_mnemonic(GTK_LABEL(GTK_BIN(item_w)->child), label_text);
/* hook up signal callback */
if(activate_cb)
g_signal_connect(G_OBJECT(item_w), "activate", activate_cb, activate_user_data);
return item_w;
}
static void
status_icon_popup_menu_cb (GtkStatusIcon * icon, guint button, guint time)
{
GtkMenu *popup_menu = GTK_MENU (gtk_menu_new ());
GtkMenu *groups_menu = GTK_MENU (gtk_menu_new ());
int i = 0;
gchar **current_name = gkbd_status_get_group_names ();
GtkWidget *item = gtk_menu_item_new_with_mnemonic (_("_Groups"));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
GTK_WIDGET (groups_menu));
item =
gtk_menu_item_new_with_mnemonic (_("Keyboard _Preferences"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_launch_capplet,
NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
item = gtk_menu_item_new_with_mnemonic (_("Show Current _Layout"));
gtk_widget_show (item);
g_signal_connect (item, "activate", popup_menu_show_layout, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);
for (i = 0; *current_name; i++, current_name++) {
gchar *image_file = gkbd_status_get_image_filename (i);
if (image_file == NULL) {
item =
gtk_menu_item_new_with_label (*current_name);
} else {
GdkPixbuf *pixbuf =
gdk_pixbuf_new_from_file_at_size (image_file,
24, 24,
NULL);
GtkWidget *img =
gtk_image_new_from_pixbuf (pixbuf);
item =
gtk_image_menu_item_new_with_label
(*current_name);
gtk_widget_show (img);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM
(item), img);
gtk_image_menu_item_set_always_show_image
(GTK_IMAGE_MENU_ITEM (item), TRUE);
g_free (image_file);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (groups_menu), item);
g_signal_connect (item, "activate",
G_CALLBACK (popup_menu_set_group),
GINT_TO_POINTER (i));
}
gtk_menu_popup (popup_menu, NULL, NULL,
gtk_status_icon_position_menu,
(gpointer) icon, button, time);
}
static void
presence_chooser_menu_add_item (GtkWidget *menu,
const gchar *str,
McPresence state)
{
GtkWidget *item;
GtkWidget *image;
const gchar *icon_name;
item = gtk_image_menu_item_new_with_label (str);
icon_name = empathy_icon_name_for_presence (state);
g_signal_connect (item, "activate",
G_CALLBACK (presence_chooser_noncustom_activate_cb),
NULL);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_widget_show (item);
g_object_set_data_full (G_OBJECT (item),
"status", g_strdup (str),
(GDestroyNotify) g_free);
g_object_set_data (G_OBJECT (item), "state", GINT_TO_POINTER (state));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
::GtkMenuItem* GtkMenuItem::CreateNative(bool registerNative)
{
::GtkMenuItem* newNativeItem;
if (this->IsSeparator()) {
return (::GtkMenuItem*) gtk_separator_menu_item_new();
} else if (this->IsCheck()) {
newNativeItem = (::GtkMenuItem*) gtk_check_menu_item_new_with_label(label.c_str());
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(newNativeItem), this->state);
} else if (this->iconPath.empty()) {
newNativeItem = (::GtkMenuItem*) gtk_menu_item_new_with_label(label.c_str());
} else {
newNativeItem = (::GtkMenuItem*) gtk_image_menu_item_new_with_label(label.c_str());
GtkWidget* image = gtk_image_new_from_file(this->iconPath.c_str());
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(newNativeItem), image);
}
gtk_widget_set_sensitive(GTK_WIDGET(newNativeItem), this->enabled);
this->SetNativeItemSubmenu(newNativeItem, this->submenu);
g_signal_connect(G_OBJECT(newNativeItem),
"activate", G_CALLBACK(GtkMenus::MenuCallback), this);
if (registerNative)
this->nativeItems.push_back(newNativeItem);
return newNativeItem;
}
static void
create_popup_menu (CajaEmblemSidebar *emblem_sidebar)
{
GtkWidget *popup, *menu_item, *menu_image;
popup = gtk_menu_new ();
/* add the "rename" menu item */
menu_image = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES,
GTK_ICON_SIZE_MENU);
gtk_widget_show (menu_image);
menu_item = gtk_image_menu_item_new_with_label (_("Rename"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
menu_image);
g_signal_connect (menu_item, "activate",
G_CALLBACK (caja_emblem_sidebar_rename_cb),
emblem_sidebar);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup), menu_item);
emblem_sidebar->details->popup_rename = menu_item;
/* add "delete" menu item */
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE,
NULL);
g_signal_connect (menu_item, "activate",
G_CALLBACK (caja_emblem_sidebar_delete_cb),
emblem_sidebar);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup), menu_item);
emblem_sidebar->details->popup_remove = menu_item;
emblem_sidebar->details->popup = popup;
}
static int motSubmenuMapMethod(Ihandle* ih)
{
int pos;
if (!ih->parent)
return IUP_ERROR;
#ifndef HILDON
if (iupMenuIsMenuBar(ih->parent))
ih->handle = gtk_menu_item_new_with_label("");
else
#endif
ih->handle = gtk_image_menu_item_new_with_label("");
if (!ih->handle)
return IUP_ERROR;
ih->serial = iupMenuGetChildId(ih);
pos = IupGetChildPos(ih->parent, ih);
gtk_menu_shell_insert((GtkMenuShell*)ih->parent->handle, ih->handle, pos);
gtk_widget_show(ih->handle);
g_signal_connect(G_OBJECT(ih->handle), "select", G_CALLBACK(gtkItemSelect), ih);
iupUpdateStandardFontAttrib(ih);
return IUP_NOERROR;
}
void configbuttonCreateMenu(CONFIGBUTTON *c) {
struct PLUGIN_SUB_ENTRY *plugin_sub;
int i;
GtkWidget *image;
GtkWidget *submenu;
c->menu = gtk_menu_new();
updatePlugins(c);
gtk_status_icon_set_from_stock(c->icon, GTK_STOCK_PREFERENCES);
for (i = 0; i < c->plugins; i++) {
c->plugin[i].item = gtk_image_menu_item_new_with_label(c->plugin[i].info->label);
if (c->plugin[i].info->icon_path != NULL) {
image = gtk_image_new_from_file(c->plugin[i].info->icon_path);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(c->plugin[i].item), image);
}
if (c->plugin[i].info->submenu == NULL)
g_signal_connect(G_OBJECT(c->plugin[i].item), "activate", G_CALLBACK(configbuttonActivate), &c->plugin[i]);
else {
plugin_sub = c->plugin[i].info->submenu;
submenu = gtk_menu_new();
while (plugin_sub != NULL) {
if (plugin_sub->visible == 0) {
plugin_sub = plugin_sub->next;
continue;
}
plugin_sub->item = gtk_image_menu_item_new_with_label(plugin_sub->label);
if (plugin_sub->icon_path != NULL) {
image = gtk_image_new_from_file(plugin_sub->icon_path);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(plugin_sub->item), image);
}
g_signal_connect(G_OBJECT(plugin_sub->item), "activate", G_CALLBACK(configbuttonActivateSubmenu), plugin_sub);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), plugin_sub->item);
plugin_sub->activate = c->plugin[i].activate;
plugin_sub = plugin_sub->next;
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(c->plugin[i].item), submenu);
}
gtk_menu_shell_append(GTK_MENU_SHELL(c->menu), c->plugin[i].item);
}
gtk_widget_show_all(c->menu);
return;
}
GuMenuGui* menugui_init(GtkBuilder* builder)
{
g_return_val_if_fail(GTK_IS_BUILDER(builder), NULL);
GuMenuGui* m = g_new0(GuMenuGui, 1);
m->menu_projcreate = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projcreate"));
m->menu_projopen = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projopen"));
m->menu_projclose = GTK_MENU_ITEM(
gtk_builder_get_object(builder, "menu_projclose"));
m->menu_cut = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_cut"));
m->menu_copy = GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_copy"));
#ifdef WIN32
// Please do NOT enable for nix, it has no place on a free OS ;)
GtkWidget* donate =
gtk_image_menu_item_new_with_label("Support this Project");
gtk_image_menu_item_set_image
(GTK_IMAGE_MENU_ITEM(donate),
GTK_WIDGET(gtk_image_new_from_stock(
GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_MENU)));
GtkWidget* helpmenu =
GTK_WIDGET(gtk_builder_get_object(builder, "menu11"));
gtk_menu_prepend(GTK_MENU(helpmenu), donate);
gtk_signal_connect_object(GTK_OBJECT(donate), "activate",
GTK_SIGNAL_FUNC(on_menu_donate_activate),
NULL);
#endif
/* TODO: There has to be a better way than this.. (bug 246)
GtkSettings *settings = gtk_settings_get_default();
gchar *iconsizes;
g_object_get(settings, "gtk-icon-sizes", &iconsizes, NULL);
if (iconsizes != NULL) {
printf("%s\n", iconsizes);
}*/
#ifdef WIN32
// The 2 non-stock menu items have their pixel size values set
// to the default 16x16 in GLADE. The normal icon-size value is
// normally set by the GTK theme in gtkrc. For themes using
// non-default icon sizes or Windows, this 16x16 value will be
// wrong. This code sets it to match the gtkrc file that we
// supply with the Windows builds:
GtkWidget* export = gtk_image_menu_item_get_image(
GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "menu_export")));
GtkWidget* update = gtk_image_menu_item_get_image(
GTK_IMAGE_MENU_ITEM(gtk_builder_get_object(builder, "menu_update")));
gtk_image_set_pixel_size(GTK_IMAGE(export), 13);
gtk_image_set_pixel_size(GTK_IMAGE(update), 13);
#endif
return m;
}
static void on_add_search_folder( GtkWidget* btn, FindFile* data )
{
GtkWidget* menu = gtk_menu_new();
GtkWidget* item;
GtkWidget* img;
const char* dir;
item = gtk_image_menu_item_new_with_label( _("Browse...") );
gtk_menu_shell_append( GTK_MENU_SHELL( menu ), item );
g_signal_connect( item, "activate", G_CALLBACK(on_add_search_browse), data );
item = gtk_separator_menu_item_new();
gtk_menu_shell_append( GTK_MENU_SHELL( menu ), item );
item = gtk_image_menu_item_new_with_label( g_get_home_dir() );
//img = gtk_image_new_from_icon_name( "gnome-fs-directory", GTK_ICON_SIZE_MENU );
img = xset_get_image( "gtk-directory", GTK_ICON_SIZE_MENU );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM( item ), img );
gtk_menu_shell_append( GTK_MENU_SHELL( menu ), item );
g_signal_connect( item, "activate", G_CALLBACK(on_add_search_home), data );
if( dir = vfs_get_desktop_dir() )
{
item = gtk_image_menu_item_new_with_label( dir );
//img = gtk_image_new_from_icon_name( "gnome-fs-desktop", GTK_ICON_SIZE_MENU );
img = xset_get_image( "gtk-directory", GTK_ICON_SIZE_MENU );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM( item ), img );
gtk_menu_shell_append( GTK_MENU_SHELL( menu ), item );
g_signal_connect( item, "activate", G_CALLBACK(on_add_search_desktop), data );
}
item = gtk_image_menu_item_new_with_label( _("Local Volumes") );
//img = gtk_image_new_from_icon_name( "gnome-dev-harddisk", GTK_ICON_SIZE_MENU );
img = xset_get_image( "gtk-harddisk", GTK_ICON_SIZE_MENU );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM( item ), img );
gtk_menu_shell_append( GTK_MENU_SHELL( menu ), item );
g_signal_connect( item, "activate", G_CALLBACK(on_add_search_volumes), data );
/* FIXME: Add all volumes */
/* FIXME: Add all bookmarks */
gtk_widget_show_all( menu );
gtk_menu_popup( GTK_MENU( menu ), NULL, NULL, (GtkMenuPositionFunc)menu_pos,
btn, 0, gtk_get_current_event_time() );
}
GtkWidget *
empathy_smiley_menu_new (EmpathySmileyManager *manager,
EmpathySmileyMenuFunc func,
gpointer user_data)
{
EmpathySmileyManagerPriv *priv = GET_PRIV (manager);
GSList *l;
GtkWidget *menu;
gint x = 0;
gint y = 0;
g_return_val_if_fail (EMPATHY_IS_SMILEY_MANAGER (manager), NULL);
g_return_val_if_fail (func != NULL, NULL);
menu = gtk_menu_new ();
for (l = priv->smileys; l; l = l->next) {
EmpathySmiley *smiley;
GtkWidget *item;
GtkWidget *image;
ActivateData *data;
smiley = l->data;
image = gtk_image_new_from_pixbuf (smiley->pixbuf);
item = gtk_image_menu_item_new_with_label ("");
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), TRUE);
gtk_menu_attach (GTK_MENU (menu), item,
x, x + 1, y, y + 1);
gtk_widget_set_tooltip_text (item, smiley->str);
data = g_slice_new (ActivateData);
data->manager = g_object_ref (manager);
data->smiley = smiley;
data->func = func;
data->user_data = user_data;
g_signal_connect_data (item, "activate",
G_CALLBACK (smiley_menu_activate_cb),
data,
smiley_menu_data_free,
0);
if (x > 3) {
y++;
x = 0;
} else {
x++;
}
}
gtk_widget_show_all (menu);
return menu;
}
GtkWidget*
hybrid_create_menu(GtkWidget *parent, const gchar *title,
const gchar *icon_name, gboolean sensitive,
GCallback callback,
gpointer user_data)
{
GtkWidget *item;
GdkPixbuf *pixbuf;
GtkWidget *image;
gchar *icon_path;
g_return_val_if_fail(title != NULL, NULL);
if (icon_name) {
icon_path = g_strdup_printf(PIXMAPS_DIR"menus/%s.png", icon_name);
item = gtk_image_menu_item_new_with_label(title);
pixbuf = gdk_pixbuf_new_from_file_at_size(icon_path, 16, 16, NULL);
if (pixbuf) {
image = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
}
g_free(icon_path);
} else {
item = gtk_image_menu_item_new_with_label(title);
}
if (parent) {
gtk_menu_shell_append(GTK_MENU_SHELL(parent), item);
}
if (!sensitive) {
gtk_widget_set_sensitive(item, FALSE);
return item;
}
if (callback) {
g_signal_connect(item, "activate", G_CALLBACK(callback), user_data);
}
return item;
}
static GtkWidget *_terminal_build_menu (GtkWidget *pWidget, gchar *cReceivedData)
{
static gpointer *my_data = NULL;
if (my_data == NULL)
my_data = g_new0 (gpointer, 2);
my_data[0] = pWidget;
my_data[1] = cReceivedData;
GtkWidget *menu = gtk_menu_new ();
GtkWidget *menu_item, *image;
menu_item = gtk_image_menu_item_new_with_label (_("Copy"));
image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(_terminal_copy), my_data);
menu_item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
menu_item = gtk_image_menu_item_new_with_label ("cd");
image = gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(_terminal_cd), my_data);
menu_item = gtk_image_menu_item_new_with_label ("cp");
image = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(_terminal_cp), my_data);
menu_item = gtk_image_menu_item_new_with_label ("mv");
image = gtk_image_new_from_stock (GTK_STOCK_GOTO_LAST, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(_terminal_mv), my_data);
menu_item = gtk_image_menu_item_new_with_label ("rm");
image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
g_signal_connect (G_OBJECT (menu_item), "activate", G_CALLBACK(_terminal_rm), my_data);
return menu;
}
