自学教程：C++ GTK_MENU_ITEM函数代码示例

MetaWindowMenu*meta_window_menu_new   (MetaFrames         *frames,                        MetaMenuOp          ops,                        MetaMenuOp          insensitive,                        Window              client_xwindow,                        unsigned long       active_workspace,                        int                 n_workspaces,                        MetaWindowMenuFunc  func,                        gpointer            data){  int i;  MetaWindowMenu *menu;  /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */  if (n_workspaces < 2)    ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES);  else if (n_workspaces == 2)    /* #151183: If we only have two workspaces, disable the menu listing them. */    ops &= ~(META_MENU_OP_WORKSPACES);  menu = g_new (MetaWindowMenu, 1);  menu->frames = frames;  menu->client_xwindow = client_xwindow;  menu->func = func;  menu->data = data;  menu->ops = ops;  menu->insensitive = insensitive;  menu->menu = gtk_menu_new ();  gtk_menu_set_screen (GTK_MENU (menu->menu),                       gtk_widget_get_screen (GTK_WIDGET (frames)));  for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++)    {      MenuItem menuitem = menuitems[i];      if (ops & menuitem.op || menuitem.op == 0)        {          GtkWidget *mi;          MenuData *md;          unsigned int key;          MetaVirtualModifier mods;          mi = menu_item_new (&menuitem, -1);          /* Set the activeness of radiobuttons. */          if (menuitem.op == META_MENU_OP_STICK)            {              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace == 0xFFFFFFFF);            }          else if (menuitem.op == META_MENU_OP_UNSTICK)            {              gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),                                              active_workspace != 0xFFFFFFFF);            }          if (menuitem.type == MENU_ITEM_WORKSPACE_LIST)            {              if (ops & META_MENU_OP_WORKSPACES)                {                  Display *display;                  Window xroot;                  GdkScreen *screen;                  GdkWindow *window;                  GtkWidget *submenu;                  int j;                  MenuItem to_another_workspace = {                    0, MENU_ITEM_NORMAL, FALSE,                    N_("Move to Another _Workspace")                  };                  meta_verbose ("Creating %d-workspace menu current space %lu/n",                      n_workspaces, active_workspace);                  window = gtk_widget_get_window (GTK_WIDGET (frames));                  display = GDK_WINDOW_XDISPLAY (window);                  screen = gdk_window_get_screen (window);                  xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));                  submenu = gtk_menu_new ();                  g_assert (mi==NULL);                  mi = menu_item_new (&to_another_workspace, -1);                  gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu);                  for (j = 0; j < n_workspaces; j++)                    {                      char *label;                      MenuItem moveitem;                      GtkWidget *submi;                      meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES,                          j + 1,                          &key, &mods);                      label = get_workspace_name_with_accel (display, xroot, j);//.........这里部分代码省略.........

static void notify_incoming_call(struct gtk_mod *mod,		struct call *call){	static const char *title = "Incoming call";	const char *msg = call_peeruri(call);	GtkWidget *call_menu;	GtkWidget *menu_item;#if defined(USE_LIBNOTIFY)	NotifyNotification *notification;	if (!notify_is_initted())		return;	notification = notify_notification_new(title, msg, "baresip");	notify_notification_set_urgency(notification, NOTIFY_URGENCY_CRITICAL);	notify_notification_show(notification, NULL);	g_object_unref(notification);#elif GLIB_CHECK_VERSION(2,40,0)	char id[64];	GVariant *target;	GNotification *notification = g_notification_new(title);	re_snprintf(id, sizeof id, "incoming-call-%p", call);	id[sizeof id - 1] = '/0';#if GLIB_CHECK_VERSION(2,42,0)	g_notification_set_priority(notification,			G_NOTIFICATION_PRIORITY_URGENT);#else	g_notification_set_urgent(notification, TRUE);#endif	target = g_variant_new_int64(GPOINTER_TO_INT(call));	g_notification_set_body(notification, msg);	g_notification_add_button_with_target_value(notification,			"Answer", "app.answer", target);	g_notification_add_button_with_target_value(notification,			"Reject", "app.reject", target);	g_application_send_notification(mod->app, id, notification);	g_object_unref(notification);#else	(void)msg;	(void)title;#endif	/* Add incoming call to the app menu */	call_menu = gtk_menu_new();	menu_item = gtk_menu_item_new_with_mnemonic("_Incoming call");	g_object_set_data(G_OBJECT(menu_item), "call", call);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),			call_menu);	gtk_menu_shell_prepend(GTK_MENU_SHELL(mod->app_menu), menu_item);	mod->incoming_call_menus = g_slist_append(mod->incoming_call_menus,			menu_item);	menu_item = gtk_menu_item_new_with_label(call_peeruri(call));	gtk_widget_set_sensitive(menu_item, FALSE);	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);	menu_item = gtk_menu_item_new_with_mnemonic("_Accept");	g_object_set_data(G_OBJECT(menu_item), "call", call);	g_signal_connect(G_OBJECT(menu_item), "activate",			G_CALLBACK(menu_on_incoming_call_answer), mod);	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);	menu_item = gtk_menu_item_new_with_mnemonic("_Reject");	g_object_set_data(G_OBJECT(menu_item), "call", call);	g_signal_connect(G_OBJECT(menu_item), "activate",			G_CALLBACK(menu_on_incoming_call_reject), mod);	gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);}

GtkUIManager *gl_ui_new (glWindow *window){	GtkUIManager            *ui;	GtkActionGroup          *actions;	GError                  *error = NULL;	GtkWidget               *recent_menu;	gl_debug (DEBUG_UI, "START");	g_return_val_if_fail (window && GL_IS_WINDOW (window), NULL);	gl_debug (DEBUG_UI, "window = %p", window);	ui = gtk_ui_manager_new ();	g_signal_connect (ui, "connect_proxy",			  G_CALLBACK (connect_proxy_cb), window);	g_signal_connect (ui, "disconnect_proxy",			  G_CALLBACK (disconnect_proxy_cb), window);	actions = gtk_action_group_new ("Actions");        gtk_action_group_set_translation_domain (actions, NULL);	gtk_action_group_add_actions (actions, entries, n_entries, GTK_WINDOW (window));	gtk_action_group_add_toggle_actions (actions, 					     toggle_entries, n_toggle_entries, 					     window);	gtk_action_group_add_toggle_actions (actions, 					     ui_toggle_entries, n_ui_toggle_entries, 					     ui);	gtk_ui_manager_insert_action_group (ui, actions, 0);	gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));	gl_debug (DEBUG_UI, "Creating ui from string");	if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, strlen (ui_info), &error)) {		g_message ("building menus failed: %s", error->message);		g_error_free (error);	}	/* Set the toolbar styles according to prefs */	set_app_main_toolbar_style (ui);	set_app_drawing_toolbar_style (ui);			/* Set view grid and markup visibility according to prefs */	set_view_style (ui);			/* add an Open Recents Submenu */        recent_menu  = gl_recent_create_menu ();	g_signal_connect (G_OBJECT (recent_menu), "item-activated",			  G_CALLBACK (gl_ui_cmd_file_open_recent), window);	gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (ui, "/MenuBar/FileMenu/FileRecentsMenu")),				   recent_menu);        set_additional_properties (ui);	gl_ui_util_set_verb_list_sensitive (ui, doc_verbs, FALSE);	gl_ui_util_set_verb_list_sensitive (ui, paste_verbs, FALSE);	gl_debug (DEBUG_UI, "END");	return ui;}

int main(int argc, char *argv[] ) {    	int i;	char track_text[4];        gtk_init (&argc, &argv);                id3win=gtk_window_new(GTK_WINDOW_TOPLEVEL);        gtk_window_set_title(GTK_WINDOW(id3win),"MP3info - An ID3 tag editor");        gtk_window_set_policy (GTK_WINDOW(id3win), FALSE,FALSE,FALSE);        gtk_widget_set_usize(id3win,450,360);        gtk_container_border_width(GTK_CONTAINER(id3win),5);        gtk_signal_connect(GTK_OBJECT(id3win), "delete_event", (GtkSignalFunc) gtk_exit, NULL);        id3win_frame_global=gtk_vbox_new(FALSE,5);	/* rmcc was here */	id3win_menu_bar = gtk_menu_bar_new();	gtk_widget_show(id3win_menu_bar);	gtk_box_pack_start(GTK_BOX(id3win_frame_global), id3win_menu_bar, FALSE, TRUE, 1);	id3win_menu_file = gtk_menu_item_new_with_label("File");	gtk_widget_show(id3win_menu_file);	gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_file);	id3win_menu_fcont = gtk_menu_new();	gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_file), id3win_menu_fcont);	id3win_menu_open = gtk_menu_item_new_with_label("Open New    ");	gtk_widget_show(id3win_menu_open);	gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_open);	gtk_signal_connect(GTK_OBJECT(id3win_menu_open), "activate",	                   GTK_SIGNAL_FUNC(open_mp3_file),	                   NULL);	id3win_menu_info = gtk_menu_item_new_with_label("Info        ");	gtk_widget_show(id3win_menu_info);	gtk_container_add(GTK_CONTAINER(id3win_menu_fcont), id3win_menu_info);	gtk_signal_connect(GTK_OBJECT(id3win_menu_info), "activate",	                   GTK_SIGNAL_FUNC(create_techinfo_win),	                   NULL);	id3win_menu_help = gtk_menu_item_new_with_label("      Help");	gtk_widget_show(id3win_menu_help);	gtk_container_add(GTK_CONTAINER(id3win_menu_bar), id3win_menu_help);	gtk_menu_item_right_justify(GTK_MENU_ITEM(id3win_menu_help));	id3win_menu_hcont = gtk_menu_new();	gtk_menu_item_set_submenu(GTK_MENU_ITEM(id3win_menu_help), id3win_menu_hcont);	id3win_menu_about = gtk_menu_item_new_with_label("About    ");	gtk_widget_show(id3win_menu_about);	gtk_container_add(GTK_CONTAINER(id3win_menu_hcont), id3win_menu_about);	gtk_signal_connect(GTK_OBJECT(id3win_menu_about), "activate",	                   GTK_SIGNAL_FUNC(about_mp3info),	                   NULL);	/* rmcc has left the building */                id3win_frame_title=gtk_frame_new("Title");        gtk_container_border_width(GTK_CONTAINER(id3win_frame_title),5);        id3win_text_title=gtk_entry_new_with_max_length(30);        gtk_container_add(GTK_CONTAINER(id3win_frame_title),id3win_text_title);        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_title,TRUE,TRUE,0);                id3win_frame_artist=gtk_frame_new("Artist");        gtk_container_border_width(GTK_CONTAINER(id3win_frame_artist),5);        id3win_text_artist=gtk_entry_new_with_max_length(30);        gtk_container_add(GTK_CONTAINER(id3win_frame_artist),id3win_text_artist);        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_artist,TRUE,TRUE,0);                id3win_frame_albyear=gtk_hbox_new(FALSE,30);        id3win_frame_album=gtk_frame_new("Album");        gtk_container_border_width(GTK_CONTAINER(id3win_frame_album),5);        id3win_text_album=gtk_entry_new_with_max_length(30);        gtk_container_add(GTK_CONTAINER(id3win_frame_album),id3win_text_album);        gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_album,TRUE,TRUE,0);                id3win_frame_year=gtk_frame_new("Year");        gtk_widget_set_usize(id3win_frame_year,2,0);        gtk_container_border_width(GTK_CONTAINER(id3win_frame_year),5);        id3win_text_year=gtk_entry_new_with_max_length(4);        gtk_container_add(GTK_CONTAINER(id3win_frame_year),id3win_text_year);        gtk_box_pack_start(GTK_BOX(id3win_frame_albyear),id3win_frame_year,TRUE,TRUE,0);        gtk_box_pack_start(GTK_BOX(id3win_frame_global),id3win_frame_albyear,TRUE,TRUE,0);                id3win_frame_comtrack=gtk_hbox_new(FALSE,30);        id3win_frame_comment=gtk_frame_new("Comment");        gtk_container_border_width(GTK_CONTAINER(id3win_frame_comment),5);        id3win_text_comment=gtk_entry_new_with_max_length(30);        gtk_container_add(GTK_CONTAINER(id3win_frame_comment),id3win_text_comment);        gtk_box_pack_start(GTK_BOX(id3win_frame_comtrack),id3win_frame_comment,TRUE,TRUE,0);                id3win_frame_track=gtk_frame_new("Track");        gtk_widget_set_usize(id3win_frame_track,2,0);        gtk_container_border_width(GTK_CONTAINER(id3win_frame_track),5);        id3win_text_track=gtk_entry_new_with_max_length(3);        gtk_container_add(GTK_CONTAINER(id3win_frame_track),id3win_text_track);//.........这里部分代码省略.........

int main (int argc, char *argv[]){    /* Vars */    GtkWidget *vbox;    GtkWidget *window;    GtkWidget *table;    GtkWidget *label;    GtkWidget *entry;    GtkWidget *button;    GtkWidget* scrolled;    GtkWidget *menubar;    GtkWidget *filemenu;    GtkWidget *file;    GtkWidget *quit;    GtkWidget *reindexer;        /* Set default directory to index */    indexdir = ".";        /* Run the indexer */    reindex(NULL, NULL);        /* Create the search objects */    createSearch();    /* Make the GUI */    gtk_init(&argc, &argv);    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    initialize_window(window);    /* Create a 10x5 table */    table = gtk_table_new (10, 5, FALSE);    gtk_container_add (GTK_CONTAINER (window), table);    /* create a new label. */    label = gtk_label_new ("Search Terms:" );    gtk_table_set_homogeneous(GTK_TABLE (table), TRUE);    gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);    entry = gtk_entry_new ();    gtk_entry_set_max_length (GTK_ENTRY (entry),1000);    gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 3, 1, 2);        button = gtk_button_new_with_label ("OR Search");    gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (orsearch), (gpointer) entry);    gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2);        button = gtk_button_new_with_label ("AND Search");    gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (andsearch), (gpointer) entry);    gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 5, 1, 2);        textview  = gtk_text_view_new();    gtk_text_view_set_editable( GTK_TEXT_VIEW (textview), 0);    gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), 0);    scrolled = gtk_scrolled_window_new(NULL, NULL);    gtk_container_add (GTK_CONTAINER (scrolled), textview);    gtk_table_attach_defaults (GTK_TABLE (table), scrolled, 0, 5, 2, 10);    vbox = gtk_vbox_new(FALSE, 0);    gtk_table_attach_defaults (GTK_TABLE (table), vbox, 0, 5, 0, 1);    menubar = gtk_menu_bar_new();    filemenu = gtk_menu_new();    file = gtk_menu_item_new_with_label("File");    reindexer = gtk_menu_item_new_with_label("Reindex");    gtk_signal_connect (GTK_OBJECT (reindexer), "activate", G_CALLBACK(reindex), NULL);    quit = gtk_menu_item_new_with_label("Quit");    gtk_signal_connect (GTK_OBJECT (quit), "activate", G_CALLBACK(destroy), NULL);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), reindexer);    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);    gtk_widget_show_all(window);    gtk_main ();    return 0;}

static voidcreate_colors (void){   static GtkWidget *window = NULL;   GtkWidget *box1 = NULL;   GtkWidget *box2 = NULL;   GtkWidget *close_button = NULL;   GtkWidget *box = NULL;   GtkWidget *separator;   GtkWidget *label;   GtkWidget *menu;   GtkWidget *root_menu;   GtkWidget *menu_bar;   gfloat *X = NULL;   gfloat *Y = NULL;   gint i, j;   GdkColor color;   GtkDataboxGraph *graph;   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);   gtk_widget_set_size_request (window, 500, 300);   g_signal_connect (G_OBJECT (window), "destroy",		     G_CALLBACK (gtk_main_quit), NULL);   gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Colors");   gtk_container_set_border_width (GTK_CONTAINER (window), 0);   box1 = gtk_vbox_new (FALSE, 0);   gtk_container_add (GTK_CONTAINER (window), box1);   box = gtk_databox_new ();   gtk_databox_set_enable_selection (GTK_DATABOX (box), FALSE);   gtk_databox_set_enable_zoom (GTK_DATABOX (box), FALSE);   color.red = 0;   color.green = 0;   color.blue = 0;   gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color);   menu = gtk_menu_new ();   root_menu = gtk_menu_item_new_with_label ("Color Menu");   gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);   menu_bar = gtk_menu_bar_new ();   gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);   gtk_box_pack_start (GTK_BOX (box1), menu_bar, FALSE, TRUE, 0);   label =      gtk_label_new      ("You can change the colors of the shown datasets via the menu./n/n");   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);   separator = gtk_hseparator_new ();   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);   g_signal_connect (G_OBJECT (box), "destroy",		     G_CALLBACK (gtk_main_quit), NULL);   for (i = 0; i < NO_OF_DATASETS; i++)   {      if (!i)	 X = g_new0 (gfloat, POINTS);      Y = g_new0 (gfloat, POINTS);      for (j = 0; j < POINTS; j++)      {	 X[j] = j;	 Y[j] = 100. * sin ((i + 1) * 2 * j * G_PI / POINTS);      }      color.red = 65535 * ((i + 1) % 2);      color.green = (65535 / 2) * ((i + 1) % 3);      color.blue = (65535 / 3) * ((i + 1) % 4);      graph = gtk_databox_points_new (POINTS, X, Y, &color, 1);      gtk_databox_graph_add (GTK_DATABOX (box), graph);      create_menu_entry (menu, i, box, graph);   }   gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05);   gtk_box_pack_start (GTK_BOX (box1), box, TRUE, TRUE, 0);   separator = gtk_hseparator_new ();   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);   box2 = gtk_vbox_new (FALSE, 10);   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);   gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);   close_button = gtk_button_new_with_label ("close");   g_signal_connect (G_OBJECT (close_button), "clicked",		     G_CALLBACK (gtk_main_quit), (gpointer) NULL);   gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);   GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);   gtk_widget_grab_default (close_button);   gtk_widget_show_all (window);//.........这里部分代码省略.........

static void *menu_get_mainwidget( void *data ){   GtkWidget *menu_item = (GtkWidget *) data;   return gtk_menu_item_get_submenu( GTK_MENU_ITEM( menu_item) );}

//.........这里部分代码省略.........		gchar *str_res_mark = g_strdup_printf(_("_Reset mark %d"), mark);		gchar *str_toggle_mark = g_strdup_printf(_("_Toggle mark %d"), mark);		gchar *str_sel_mark = g_strdup_printf(_("_Select mark %d"), mark);		gchar *str_sel_mark_or = g_strdup_printf(_("_Add mark %d"), mark);		gchar *str_sel_mark_and = g_strdup_printf(_("_Intersection with mark %d"), mark);		gchar *str_sel_mark_minus = g_strdup_printf(_("_Unselect mark %d"), mark);		g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);		vf->active_mark = mark;		vf->clicked_mark = 0;		menu_item_add_sensitive(menu, str_set_mark, active,					G_CALLBACK(vf_pop_menu_set_mark_sel_cb), vf);		menu_item_add_sensitive(menu, str_res_mark, active,					G_CALLBACK(vf_pop_menu_res_mark_sel_cb), vf);		menu_item_add_sensitive(menu, str_toggle_mark, active,					G_CALLBACK(vf_pop_menu_toggle_mark_sel_cb), vf);		menu_item_add_divider(menu);		menu_item_add_sensitive(menu, str_sel_mark, active,					G_CALLBACK(vf_pop_menu_sel_mark_cb), vf);		menu_item_add_sensitive(menu, str_sel_mark_or, active,					G_CALLBACK(vf_pop_menu_sel_mark_or_cb), vf);		menu_item_add_sensitive(menu, str_sel_mark_and, active,					G_CALLBACK(vf_pop_menu_sel_mark_and_cb), vf);		menu_item_add_sensitive(menu, str_sel_mark_minus, active,					G_CALLBACK(vf_pop_menu_sel_mark_minus_cb), vf);		menu_item_add_divider(menu);		g_free(str_set_mark);		g_free(str_res_mark);		g_free(str_toggle_mark);		g_free(str_sel_mark);		g_free(str_sel_mark_and);		g_free(str_sel_mark_or);		g_free(str_sel_mark_minus);		}	vf->editmenu_fd_list = vf_pop_menu_file_list(vf);	submenu_add_edit(menu, &item, G_CALLBACK(vf_pop_menu_edit_cb), vf, vf->editmenu_fd_list);	gtk_widget_set_sensitive(item, active);	menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, active,				      G_CALLBACK(vf_pop_menu_view_cb), vf);	menu_item_add_divider(menu);	menu_item_add_stock_sensitive(menu, _("_Copy..."), GTK_STOCK_COPY, active,				      G_CALLBACK(vf_pop_menu_copy_cb), vf);	menu_item_add_sensitive(menu, _("_Move..."), active,				G_CALLBACK(vf_pop_menu_move_cb), vf);	menu_item_add_sensitive(menu, _("_Rename..."), active,				G_CALLBACK(vf_pop_menu_rename_cb), vf);	menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, active,				      G_CALLBACK(vf_pop_menu_delete_cb), vf);	menu_item_add_sensitive(menu, _("_Copy path"), active,				G_CALLBACK(vf_pop_menu_copy_path_cb), vf);	menu_item_add_sensitive(menu, _("Enable file _grouping"), active,				G_CALLBACK(vf_pop_menu_enable_grouping_cb), vf);	menu_item_add_sensitive(menu, _("Disable file groupi_ng"), active,				G_CALLBACK(vf_pop_menu_disable_grouping_cb), vf);	menu_item_add_divider(menu);	submenu = submenu_add_sort(NULL, G_CALLBACK(vf_pop_menu_sort_cb), vf,				   FALSE, FALSE, TRUE, vf->sort_method);	menu_item_add_divider(submenu);	menu_item_add_check(submenu, _("Ascending"), vf->sort_ascend,			    G_CALLBACK(vf_pop_menu_sort_ascend_cb), vf);	item = menu_item_add(menu, _("_Sort"), NULL, NULL);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);	item = menu_item_add_radio(menu, _("View as _List"), GINT_TO_POINTER(FILEVIEW_LIST), vf->type == FILEVIEW_LIST,                                           G_CALLBACK(vf_pop_menu_toggle_view_type_cb), vf);	item = menu_item_add_radio(menu, _("View as _Icons"), GINT_TO_POINTER(FILEVIEW_ICON), vf->type == FILEVIEW_ICON,                                           G_CALLBACK(vf_pop_menu_toggle_view_type_cb), vf);	switch (vf->type)	{	case FILEVIEW_LIST:		menu_item_add_check(menu, _("Show _thumbnails"), VFLIST(vf)->thumbs_enabled,				    G_CALLBACK(vflist_pop_menu_thumbs_cb), vf);		break;	case FILEVIEW_ICON:		menu_item_add_check(menu, _("Show filename _text"), VFICON(vf)->show_text,				    G_CALLBACK(vficon_pop_menu_show_names_cb), vf);		break;	}		menu_item_add_stock(menu, _("Re_fresh"), GTK_STOCK_REFRESH, G_CALLBACK(vf_pop_menu_refresh_cb), vf);	return menu;}

//.........这里部分代码省略.........    mm = MM_ZOOM;    menu_item = gtk_menu_item_new_with_label("Zoom");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********/    //ROTATE    mm = MM_ROTATE;    menu_item = gtk_menu_item_new_with_label("rotate");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********//**********/    //Single Select    mm = MM_SINGLE_SELECT;    menu_item = gtk_menu_item_new_with_label("select");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********/    //Rectangle Select    mm = MM_RECTANGULAR_SELECT;    menu_item = gtk_menu_item_new_with_label("rect select");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********//**********/    //Rectangle -x Select    mm = MM_RECTANGULAR_X_SELECT;    menu_item = gtk_menu_item_new_with_label("rect-x select");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********//**********/    //Move    mm = MM_MOVE;    menu_item = gtk_menu_item_new_with_label("Move");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********/    //activate magnifier    mm = MM_MAGNIFIER;		//magnifier ,fisheye etc starts at 20    menu_item = gtk_menu_item_new_with_label("Magnifier");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********/    //activate fisheye magnifier    mm = MM_FISHEYE_MAGNIFIER;    menu_item = gtk_menu_item_new_with_label("Fisheye Magnifier");    gtk_menu_shell_append(GTK_MENU_SHELL(actions_menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(switch_Mouse), (gpointer) mm);    gtk_widget_show(menu_item);/**********/    editing_menu = gtk_menu_new();    /* NODE */    menu_item = gtk_menu_item_new_with_label("Node");    gtk_menu_shell_append(GTK_MENU_SHELL(editing_menu), menu_item);    gtk_widget_show(menu_item);    /* EDGE */    menu_item = gtk_menu_item_new_with_label("Edge");    gtk_menu_shell_append(GTK_MENU_SHELL(editing_menu), menu_item);    gtk_widget_show(menu_item);    menu = gtk_menu_new();    /* Actions */    menu_item = gtk_menu_item_new_with_label("Mouse");    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), actions_menu);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);    gtk_widget_show(menu_item);    /* NEW */    menu_item = gtk_menu_item_new_with_label("New");    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), editing_menu);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);    gtk_widget_show(menu_item);    /* Quit */    menu_item = gtk_menu_item_new_with_label("Quit");    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);    g_signal_connect(G_OBJECT(menu_item), "activate",		     G_CALLBACK(gtk_main_quit), NULL);    gtk_widget_show(menu_item);    return menu;}

/* Constructs the main program window. The specified mode will be the one * initially selected in the Vis menu */voidwindow_init( FsvMode fsv_mode ){	GtkWidget *main_window_w;	GtkWidget *main_vbox_w;	GtkWidget *menu_bar_w;	GtkWidget *menu_w;	GtkWidget *menu_item_w;	GtkWidget *hpaned_w;	GtkWidget *vpaned_w;	GtkWidget *left_vbox_w;	GtkWidget *right_vbox_w;	GtkWidget *hbox_w;	GtkWidget *button_w;	GtkWidget *frame_w;	GtkWidget *dir_ctree_w;	GtkWidget *file_clist_w;        GtkWidget *gl_area_w;	GtkWidget *x_scrollbar_w;	GtkWidget *y_scrollbar_w;	int window_width, window_height;	/* Main window widget */	main_window_w = gtk_window_new( GTK_WINDOW_TOPLEVEL );	gtk_window_set_title( GTK_WINDOW(main_window_w), "fsv" );	gtk_window_set_wmclass( GTK_WINDOW(main_window_w), "main", "fsv" );	gtk_window_set_policy( GTK_WINDOW(main_window_w), TRUE, TRUE, TRUE );	window_width = 3 * gdk_screen_width( ) / 4;	window_height = 2584 * window_width / 4181;	gtk_widget_set_usize( main_window_w, window_width, window_height );	gtk_signal_connect( GTK_OBJECT(main_window_w), "delete_event", GTK_SIGNAL_FUNC(gtk_main_quit), NULL );	gtk_quit_add_destroy( 1, GTK_OBJECT(main_window_w) );	/* Main vertical box widget */	main_vbox_w = gui_vbox_add( main_window_w, 0 );	/* Build menu bar */	/* Menu bar widget */	menu_bar_w = gtk_menu_bar_new( );	gtk_box_pack_start( GTK_BOX(main_vbox_w), menu_bar_w, FALSE, FALSE, 0 );	gtk_widget_show( menu_bar_w );	/* File menu */	menu_w = gui_menu_add( menu_bar_w, _("File") );	/* File menu items */	menu_item_w = gui_menu_item_add( menu_w, _("Change root..."), on_file_change_root_activate, NULL );	gui_keybind( menu_item_w, _("^N") );	G_LIST_APPEND(sw_widget_list, menu_item_w);#if 0	gui_menu_item_add( menu_w, _("Save settings"), on_file_save_settings_activate, NULL );#endif	gui_separator_add( menu_w );	menu_item_w = gui_menu_item_add( menu_w, _("Exit"), on_file_exit_activate, NULL );	gui_keybind( menu_item_w, _("^Q") );	/* Vis menu */	menu_w = gui_menu_add( menu_bar_w, _("Vis") );	/* Vis menu items */	gui_radio_menu_begin( fsv_mode -1 );#if 0 /* DiscV mode needs more work */	gui_radio_menu_item_add( menu_w, _("DiscV"), on_vis_discv_activate, NULL );/* Note: don't forget to remove the "-1" three lines up */#endif	gui_radio_menu_item_add( menu_w, _("MapV"), on_vis_mapv_activate, NULL );	gui_radio_menu_item_add( menu_w, _("TreeV"), on_vis_treev_activate, NULL );	/* Color menu */	menu_w = gui_menu_add( menu_bar_w, _("Colors") );	/* Color menu items */	gui_radio_menu_begin( 0 );	menu_item_w = gui_radio_menu_item_add( menu_w, _("By node type"), on_color_by_nodetype_activate, NULL );	G_LIST_APPEND(sw_widget_list, menu_item_w);	color_by_nodetype_rmenu_item_w = menu_item_w;	menu_item_w = gui_radio_menu_item_add( menu_w, _("By timestamp"), on_color_by_timestamp_activate, NULL );	G_LIST_APPEND(sw_widget_list, menu_item_w);	color_by_timestamp_rmenu_item_w = menu_item_w;	menu_item_w = gui_radio_menu_item_add( menu_w, _("By wildcards"), on_color_by_wildcards_activate, NULL );	G_LIST_APPEND(sw_widget_list, menu_item_w);	color_by_wpattern_rmenu_item_w = menu_item_w;	gui_separator_add( menu_w );	gui_menu_item_add( menu_w, _("Setup..."), on_color_setup_activate, NULL );#ifdef DEBUG	/* Debug menu */	menu_w = gui_menu_add( menu_bar_w, "Debug" );	/* Debug menu items */	gui_menu_item_add( menu_w, "Memory totals", debug_show_mem_totals, NULL );	gui_menu_item_add( menu_w, "Memory summary", debug_show_mem_summary, NULL );	gui_menu_item_add( menu_w, "Memory stats", debug_show_mem_stats, NULL );	gui_separator_add( menu_w );	gui_menu_item_add( menu_w, "GLib memory profile", g_mem_profile, NULL );	gui_menu_item_add( menu_w, "GMemChunk info", g_mem_chunk_info, NULL );#endif	/* Help menu (right-justified) */	menu_w = gui_menu_add( menu_bar_w, _("Help") );	gtk_menu_item_right_justify( GTK_MENU_ITEM(GTK_MENU(menu_w)->parent_menu_item) );//.........这里部分代码省略.........

void ZLGtkApplicationWindow::MenuBuilder::processSepartor(ZLMenubar::Separator&) {	GtkMenuItem *gtkItem = GTK_MENU_ITEM(gtk_separator_menu_item_new());	gtk_menu_shell_append(GTK_MENU_SHELL(myMenuStack.top()), GTK_WIDGET(gtkItem));	gtk_widget_show_all(GTK_WIDGET(gtkItem));}

void pMenu::constructor() {  gtkMenu = gtk_menu_new();  widget = gtk_image_menu_item_new_with_mnemonic("");  gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), gtkMenu);  setText(menu.state.text);}

static void macmenu_construct(AppletType* applet){  MacMenu *mmb = g_slice_new0(MacMenu);  mmb->applet = applet;  mmb->screen = wnck_screen_get(gdk_screen_get_number(      gtk_widget_get_screen(GTK_WIDGET(applet))      ));  mmb->mbars_scks = g_hash_table_new(NULL, NULL);  mmb->title_subs = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);  mmb->ts_mtime = 0;  mmb->basebox = GTK_BOX(gtk_hbox_new(FALSE, 0));  gtk_container_set_border_width(GTK_CONTAINER(mmb->basebox), 0);  gtk_container_add(GTK_CONTAINER(applet), GTK_WIDGET(mmb->basebox));  mmb->label = GTK_LABEL(gtk_label_new(MAIN_LABEL_TEXT));  PangoAttrList *pattr = pango_attr_list_new();  PangoAttribute *pa = pango_attr_weight_new(PANGO_WEIGHT_BOLD);  pa->start_index = 0; pa->end_index = 1024;  pango_attr_list_insert(pattr, pa);  gtk_label_set_attributes(mmb->label, pattr);  pango_attr_list_unref(pattr);  gtk_label_set_ellipsize(mmb->label, PANGO_ELLIPSIZE_END);  gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);  gtk_label_set_single_line_mode(mmb->label, TRUE);  gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->label), FALSE, FALSE, 0);  mmb->label_space = gtk_event_box_new();  gtk_widget_set_size_request(mmb->label_space, 8, 1);  gtk_box_pack_start(mmb->basebox, mmb->label_space, FALSE, FALSE, 0);  mmb->notebook = GTK_NOTEBOOK(gtk_notebook_new());  gtk_notebook_set_show_tabs(mmb->notebook, FALSE);  gtk_notebook_set_show_border(mmb->notebook, FALSE);  gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->notebook), TRUE, TRUE, 0);  mmb->dummysck = gtk_hbox_new(FALSE, 0);  gtk_notebook_append_page(mmb->notebook, mmb->dummysck, NULL);  mmb->mainsck = gtk_hbox_new(FALSE, SHORTCUT_SPACING);  gtk_notebook_append_page(mmb->notebook, mmb->mainsck, NULL);  //initialize_mainsck(mmb);  mmb->button = GTK_BUTTON(gtk_button_new());  gtk_button_set_relief(mmb->button, GTK_RELIEF_NONE);  gtk_button_set_focus_on_click(GTK_BUTTON(mmb->button), FALSE);  gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->button),                     FALSE, FALSE, 0);  g_signal_connect(mmb->screen, "active-window-changed",                   G_CALLBACK(desktop_active_window_changed), mmb);  g_signal_connect(mmb->screen, "window-opened",                   G_CALLBACK(desktop_window_opened), mmb);#ifdef FOR_XFCE  g_signal_connect(applet, "free-data",                   G_CALLBACK(macmenu_free_data), mmb);  g_signal_connect(applet, "size-changed",                   G_CALLBACK(macmenu_set_size), mmb);  // setup panel applet  gtk_widget_show_all(GTK_WIDGET(mmb->basebox));  xfce_panel_plugin_add_action_widget (applet, GTK_WIDGET(mmb->button));  xfce_panel_plugin_set_expand(applet, TRUE);  macmenu_set_size(applet, xfce_panel_plugin_get_size(applet), mmb);  // load config, set popup  macmenu_load_from_rc(mmb);  GtkWidget* label_toggle = gtk_check_menu_item_new_with_label("Hide Label");  g_signal_connect(label_toggle, "toggled", G_CALLBACK(on_label_toggled), mmb);  gtk_widget_show(label_toggle);  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(label_toggle), mmb->hide_label);  gtk_check_menu_item_toggled(GTK_CHECK_MENU_ITEM(label_toggle));  xfce_panel_plugin_menu_insert_item(mmb->applet, GTK_MENU_ITEM(label_toggle));#elif FOR_GNOME  g_signal_connect(applet, "destroy", G_CALLBACK(macmenu_free_data), mmb);  // setup panel applet  gtk_widget_show_all(GTK_WIDGET(applet));  g_signal_connect(GTK_WIDGET(mmb->button), "pressed",                   G_CALLBACK(on_button_pressed), mmb);  panel_applet_set_flags (applet, PANEL_APPLET_EXPAND_MAJOR);  macmenu_set_size(applet, panel_applet_get_size(applet), mmb);  // load config, set popup  mmb->gconf = gconf_client_get_default();  macmenu_load_from_gconf(mmb);  macmenu_write_gconf(mmb);  static const char toggle_menu_xml [] =   "<popup name=/"button3/">/n"   "   <menuitem name=/"hide_label/" "   "             verb=/"hide_label/" "   "           _label=/"_Hide Label/"/n"   "             type=/"toggle/"/>/n"   "</popup>/n";  static const BonoboUIVerb toggle_menu_verbs[] =  {    BONOBO_UI_VERB_END  };  panel_applet_setup_menu(mmb->applet, toggle_menu_xml, toggle_menu_verbs, mmb);  BonoboUIComponent* popup_component = panel_applet_get_popup_component(mmb->applet);  bonobo_ui_component_set_prop(popup_component, "/commands/hide_label",                               "state", mmb->hide_label ? "1": "0", NULL);//.........这里部分代码省略.........

static void bar_pane_keywords_menu_popup(GtkWidget *widget, PaneKeywordsData *pkd, gint x, gint y){	GtkWidget *menu;	GtkWidget *item;	GtkWidget *submenu;        GtkTreeViewDropPosition pos;        if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);        pkd->click_tpath = NULL;	gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);	menu = popup_menu_short_lived();	menu_item_add_stock(menu, _("Add keyword"), GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);	menu_item_add_divider(menu);	menu_item_add(menu, _("Add keyword to all selected images"), G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);	menu_item_add_divider(menu);	if (pkd->click_tpath)		{		/* for the entry */		gchar *text;		gchar *mark;		gint i;		GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));		GtkTreeIter iter;                gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);		gchar *name;		gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,						 FILTER_KEYWORD_COLUMN_MARK, &mark, -1);		text = g_strdup_printf(_("Hide /"%s/""), name);		menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);		g_free(text);		submenu = gtk_menu_new();		for (i = 0; i < FILEDATA_MARKS_SIZE; i++)			{			text = g_strdup_printf(_("Mark %d"), i + 1);			item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);			g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));			g_free(text);			}		text = g_strdup_printf(_("Connect /"%s/" to mark"), name);		item = menu_item_add(menu, text, NULL, NULL);		gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);		g_free(text);		menu_item_add_divider(menu);		text = g_strdup_printf(_("Edit /"%s/""), name);		menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);		g_free(text);		text = g_strdup_printf(_("Remove /"%s/""), name);		menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);		g_free(text);		if (mark && mark[0])			{			text = g_strdup_printf(_("Disconnect /"%s/" from mark %s"), name, mark);			menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);			g_free(text);			}		menu_item_add_divider(menu);		g_free(mark);		g_free(name);		}	/* for the pane */	menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);	menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);	menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);	menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);	submenu = gtk_menu_new();	item = menu_item_add(menu, _("On any change"), NULL, NULL);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);	menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);	menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);	menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);}

int main (int argc, char **argv){  static GtkWidget *window = NULL;  GtkWidget *box1;  GtkWidget *box2;  GtkWidget *button;  GtkWidget *optionmenu;  GtkWidget *separator;  gtk_init (&argc, &argv);    if (!window)    {      GtkWidget *menubar;      GtkWidget *menu;      GtkWidget *submenu;      GtkWidget *menuitem;      GtkAccelGroup *accel_group;            window = gtk_window_new (GTK_WINDOW_TOPLEVEL);            g_signal_connect (window, "destroy",			G_CALLBACK(gtk_main_quit), NULL);      g_signal_connect (window, "delete-event",			G_CALLBACK (gtk_true), NULL);            accel_group = gtk_accel_group_new ();      gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);      gtk_window_set_title (GTK_WINDOW (window), "menus");      gtk_container_set_border_width (GTK_CONTAINER (window), 0);                  box1 = gtk_vbox_new (FALSE, 0);      gtk_container_add (GTK_CONTAINER (window), box1);      gtk_widget_show (box1);            menubar = gtk_menu_bar_new ();      gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);      gtk_widget_show (menubar);            menu = create_menu (2, TRUE);            menuitem = gtk_menu_item_new_with_label ("test/nline2");      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);      gtk_widget_show (menuitem);            menuitem = gtk_menu_item_new_with_label ("dynamic");      submenu = create_menu (3, TRUE);      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);      gtk_widget_show (menuitem);            g_timeout_add (250, change_item, submenu);      menuitem = gtk_menu_item_new_with_label ("bar");      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));      gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);      gtk_widget_show (menuitem);            box2 = gtk_vbox_new (FALSE, 10);      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);      gtk_widget_show (box2);            menu = create_menu (1, FALSE);      gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);            menuitem = gtk_separator_menu_item_new ();      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);      gtk_widget_show (menuitem);            menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);      gtk_widget_show (menuitem);      gtk_widget_add_accelerator (menuitem,				  "activate",				  accel_group,				  GDK_F1,				  0,				  GTK_ACCEL_VISIBLE);      menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);      gtk_widget_show (menuitem);      gtk_widget_add_accelerator (menuitem,				  "activate",				  accel_group,				  GDK_F2,				  0,				  GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);      menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);      gtk_widget_show (menuitem);      gtk_widget_add_accelerator (menuitem,				  "activate",				  accel_group,//.........这里部分代码省略.........

/** * main routine, parses args and reads from console */int main(int argc, char *argv[]){	GtkWidget *menubar, *menu, *menuitem, *vbox;	GtkWidget *dummMenu, *guestMenu, *switchMenu;	enumerator_t *enumerator;	guest_t *guest;	library_init(NULL);	gtk_init(&argc, &argv);	pages = linked_list_create();	dumm = dumm_create(NULL);	/* setup window */	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);	gtk_window_set_title(GTK_WINDOW (window), "Dumm");	gtk_window_set_default_size(GTK_WINDOW (window), 1000, 500);	g_signal_connect(G_OBJECT(vte_reaper_get()), "child-exited",					 G_CALLBACK(child_exited), NULL);	/* add vbox with menubar, notebook */	vbox = gtk_vbox_new(FALSE, 0);	gtk_container_add(GTK_CONTAINER(window), vbox);	menubar = gtk_menu_bar_new();	gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);	notebook = gtk_notebook_new();	g_object_set(G_OBJECT(notebook), "homogeneous", TRUE, NULL);	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);	gtk_container_add(GTK_CONTAINER(vbox), notebook);	/* Dumm menu */	menu = gtk_menu_new();	dummMenu = gtk_menu_item_new_with_mnemonic("_Dumm");	gtk_menu_bar_append(GTK_MENU_BAR(menubar), dummMenu);	gtk_widget_show(dummMenu);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(dummMenu), menu);	/* Dumm -> exit */	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(quit), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest menu */	menu = gtk_menu_new();	guestMenu = gtk_menu_item_new_with_mnemonic("_Guest");	gtk_menu_bar_append(GTK_MENU_BAR(menubar), guestMenu);	gtk_widget_show(guestMenu);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(guestMenu), menu);	/* Guest -> new */	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(create_guest), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest -> delete */	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(delete_guest), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	menuitem = gtk_separator_menu_item_new();	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest -> start */	menuitem = gtk_menu_item_new_with_mnemonic("_Start");	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(start_guest), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest -> startall */	menuitem = gtk_menu_item_new_with_mnemonic("Start _all");	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(start_all_guests), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest -> stop */	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_STOP, NULL);	g_signal_connect(G_OBJECT(menuitem), "activate",					 G_CALLBACK(stop_guest), NULL);	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	menuitem = gtk_separator_menu_item_new();	gtk_menu_append(GTK_MENU(menu), menuitem);	gtk_widget_show(menuitem);	/* Guest -> connect */	menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_CONNECT, NULL);//.........这里部分代码省略.........

void ui_set_menu() {    mwin->menu = gtk_menu_bar_new();    GtkAccelGroup *group_file = ui_set_menu_item(&(mwin->menu_file),         &(mwin->menu_file_item), "_File");    GtkAccelGroup *group_edit = ui_set_menu_item(&(mwin->menu_edit),         &(mwin->menu_edit_item), "_Edit");    GtkAccelGroup *group_help = ui_set_menu_item(&(mwin->menu_help),         &(mwin->menu_help_item), "_Help");    /* create submenu items */    mwin->menu_file_item_open = gtk_menu_item_new_with_mnemonic("_Open");    mwin->menu_file_item_compare = gtk_menu_item_new_with_mnemonic("_Compare To");    mwin->menu_file_item_exit = gtk_menu_item_new_with_mnemonic("_Exit");    mwin->menu_file_item_space = gtk_separator_menu_item_new();    mwin->menu_edit_item_update = gtk_menu_item_new_with_mnemonic("_Update");    mwin->menu_edit_item_purge = gtk_menu_item_new_with_mnemonic("_Purge Lists");    mwin->menu_help_item_about = gtk_menu_item_new_with_mnemonic("_About");    /* add accelerator keys to menu */    gtk_widget_add_accelerator(mwin->menu_file_item_open, "activate",         group_file, GDK_KEY_O, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    gtk_widget_add_accelerator(mwin->menu_file_item_compare, "activate",         group_file, GDK_KEY_L, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    gtk_widget_add_accelerator(mwin->menu_file_item_exit, "activate",         group_file, GDK_KEY_Q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    gtk_widget_add_accelerator(mwin->menu_edit_item_update, "activate",         group_edit, GDK_KEY_U, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    gtk_widget_add_accelerator(mwin->menu_edit_item_purge, "activate",         group_edit, GDK_KEY_P, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    gtk_widget_add_accelerator(mwin->menu_help_item_about, "activate",         group_help, GDK_KEY_A, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);    /* append menu items to menus */    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_open);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_compare);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_space);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_file), mwin->menu_file_item_exit);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_update);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_edit), mwin->menu_edit_item_purge);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu_help), mwin->menu_help_item_about);    /* attach callback functions to menu-items */    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_open),         "activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_mov_tab);    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_compare),         "activate", G_CALLBACK(menu_signal_open), (gpointer)nb_lists_lst_tab);    g_signal_connect_swapped(G_OBJECT(mwin->menu_file_item_exit),         "activate", G_CALLBACK(menu_signal_quit), (gpointer)mwin->main);    g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_update),         "activate", G_CALLBACK(menu_signal_update), (gpointer)mwin->main);    g_signal_connect_swapped(G_OBJECT(mwin->menu_edit_item_purge),         "activate", G_CALLBACK(menu_signal_purge), (gpointer)mwin->main);    g_signal_connect_swapped(G_OBJECT(mwin->menu_help_item_about),         "activate", G_CALLBACK(menu_signal_about), (gpointer)mwin->main);    /* add submenus to menu items */    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_file_item),         mwin->menu_file);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_edit_item),         mwin->menu_edit);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(mwin->menu_help_item),         mwin->menu_help);    /* add to main menubar */    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_file_item);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_edit_item);    gtk_menu_shell_append(GTK_MENU_SHELL(mwin->menu), mwin->menu_help_item);}

void open_mainwindow (){	mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);	gtk_window_set_position(GTK_WINDOW(mainwin), GTK_WIN_POS_CENTER);  	gtk_window_set_default_size(GTK_WINDOW(mainwin), 250, 200);  	gtk_window_set_title(GTK_WINDOW(mainwin), "Bakamoona v 0.1");	gtk_window_set_icon(GTK_WINDOW(mainwin), create_pixbuf("images/bkm.png"));	layout = gtk_vbox_new (FALSE, 0);	gtk_container_add (GTK_CONTAINER (mainwin), layout);	menubar = gtk_menu_bar_new ();/*  System | Maintenance | Finance | Search | Statistics | About*/    // System    sysmenu = gtk_menu_new();    sys_menu_item = gtk_menu_item_new_with_label ("System");    gtk_menu_item_set_submenu (GTK_MENU_ITEM(sys_menu_item), sysmenu);    // adding bus    bus_item = gtk_menu_item_new_with_label ("Bus");    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), bus_item);    busmenu = gtk_menu_new ();    gtk_menu_item_set_submenu (GTK_MENU_ITEM(bus_item), busmenu);    addbus = gtk_menu_item_new_with_label ("Add Bus");    updatebus = gtk_menu_item_new_with_label ("Update Bus");    deletebus = gtk_menu_item_new_with_label ("Delete Bus");    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), addbus);    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), updatebus);    gtk_menu_shell_append (GTK_MENU_SHELL(busmenu), deletebus);    // adding owner    owner_item = gtk_menu_item_new_with_label ("Owner");    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), owner_item);    ownermenu = gtk_menu_new ();    gtk_menu_item_set_submenu (GTK_MENU_ITEM(owner_item), ownermenu);    addowner = gtk_menu_item_new_with_label ("Add Owner");    updateowner = gtk_menu_item_new_with_label ("Update Owner");    deleteowner = gtk_menu_item_new_with_label ("Delete Owner");    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), addowner);    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), updateowner);    gtk_menu_shell_append (GTK_MENU_SHELL(ownermenu), deleteowner);    // adding sparepart     sp_item = gtk_menu_item_new_with_label ("Spare Part");    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), sp_item);    spmenu = gtk_menu_new ();    gtk_menu_item_set_submenu (GTK_MENU_ITEM(sp_item), spmenu);    addsp = gtk_menu_item_new_with_label ("Add Spare Part");    updatesp = gtk_menu_item_new_with_label ("Update Spare Part");    deletesp = gtk_menu_item_new_with_label ("Delete Spare Part");    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), addsp);    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), updatesp);    gtk_menu_shell_append (GTK_MENU_SHELL(spmenu), deletesp);        // adding worker    worker_item = gtk_menu_item_new_with_label ("Worker");    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), worker_item);    workermenu = gtk_menu_new ();    gtk_menu_item_set_submenu (GTK_MENU_ITEM(worker_item), workermenu);    addworker = gtk_menu_item_new_with_label ("Add Worker");    updateworker = gtk_menu_item_new_with_label ("Update Worker");    deleteworker = gtk_menu_item_new_with_label ("Delete Worker");    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), addworker);    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), updateworker);    gtk_menu_shell_append (GTK_MENU_SHELL(workermenu), deleteworker);        // adding packages    package_item = gtk_menu_item_new_with_label ("Package");    gtk_menu_shell_append (GTK_MENU_SHELL(sysmenu), package_item);    packagemenu = gtk_menu_new ();    gtk_menu_item_set_submenu (GTK_MENU_ITEM(package_item), packagemenu);    addpackage = gtk_menu_item_new_with_label ("Add Package");    updatepackage = gtk_menu_item_new_with_label ("Update Package");    deletepackage = gtk_menu_item_new_with_label ("Delete Package");    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), addpackage);    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), updatepackage);    gtk_menu_shell_append (GTK_MENU_SHELL(packagemenu), deletepackage);	sep = gtk_separator_menu_item_new();    quit = gtk_menu_item_new_with_label("Quit");//.........这里部分代码省略.........

//.........这里部分代码省略.........                else // continue the radio group                {                    group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (m_prevRadio));                    m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );                    label = GTK_LABEL( GTK_BIN(menuItem)->child );                }                break;            }            default:                wxFAIL_MSG( _T("unexpected menu item kind") );                // fall through            case wxITEM_NORMAL:            {                menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );                label = GTK_LABEL( GTK_BIN(menuItem)->child );                m_prevRadio = NULL;                break;            }        }    }    guint accel_key;    GdkModifierType accel_mods;    wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*mitem) );    // wxPrintf( wxT("item: %s hotkey %s/n"), mitem->GetText().c_str(), GetGtkHotKey(*mitem).c_str() );    gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);    if (accel_key != 0)    {        gtk_widget_add_accelerator (GTK_WIDGET(menuItem),                                    "activate",                                    m_accel,                                    accel_key,                                    accel_mods,                                    GTK_ACCEL_VISIBLE);    }    if (pos == -1)        gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem);    else        gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);    gtk_widget_show( menuItem );    if ( !mitem->IsSeparator() )    {        wxASSERT_MSG( menuItem, wxT("invalid menuitem") );        gtk_signal_connect( GTK_OBJECT(menuItem), "select",                            GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),                            (gpointer)this );        gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",                            GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),                            (gpointer)this );        if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )        {            gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );            gtk_widget_show( mitem->GetSubMenu()->m_menu );            // if adding a submenu to a menu already existing in the menu bar, we            // must set invoking window to allow processing events from this            // submenu            if ( m_invokingWindow )                wxMenubarSetInvokingWindow(mitem->GetSubMenu(), m_invokingWindow);        }        else        {            gtk_signal_connect( GTK_OBJECT(menuItem), "activate",                                GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),                                (gpointer)this );        }        guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) );        if (accel_key != GDK_VoidSymbol)        {            gtk_widget_add_accelerator (menuItem,                                        "activate_item",                                        gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menu)),                                        accel_key,                                        GDK_MOD1_MASK,                                        GTK_ACCEL_LOCKED);        }    }    mitem->SetMenuItem(menuItem);    if (ms_locked)    {        // This doesn't even exist!        // gtk_widget_lock_accelerators(mitem->GetMenuItem());    }    return true;}

bool WebPopupMenuProxyGtk::typeAheadFind(GdkEventKey* event){    // If we were given a non-printable character just skip it.    gunichar unicodeCharacter = gdk_keyval_to_unicode(event->keyval);    if (!g_unichar_isprint(unicodeCharacter)) {        resetTypeAheadFindState();        return false;    }    glong charactersWritten;    GUniquePtr<gunichar2> utf16String(g_ucs4_to_utf16(&unicodeCharacter, 1, nullptr, &charactersWritten, nullptr));    if (!utf16String) {        resetTypeAheadFindState();        return false;    }    // If the character is the same as the last character, the user is probably trying to    // cycle through the menulist entries. This matches the WebCore behavior for collapsed menulists.    static const uint32_t searchTimeoutMs = 1000;    bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter;    if (event->time - m_previousKeyEventTimestamp > searchTimeoutMs)        m_currentSearchString = String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten);    else if (repeatingCharacter)        m_currentSearchString.append(String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten));    m_previousKeyEventTimestamp = event->time;    m_previousKeyEventCharacter = unicodeCharacter;    GUniquePtr<GList> children(gtk_container_get_children(GTK_CONTAINER(m_popup)));    if (!children)        return true;    // We case fold before searching, because strncmp does not handle non-ASCII characters.    GUniquePtr<gchar> searchStringWithCaseFolded(g_utf8_casefold(m_currentSearchString.utf8().data(), -1));    size_t prefixLength = strlen(searchStringWithCaseFolded.get());    // If a menu item has already been selected, start searching from the current    // item down the list. This will make multiple key presses of the same character    // advance the selection.    GList* currentChild = children.get();    if (m_currentlySelectedMenuItem) {        currentChild = g_list_find(children.get(), m_currentlySelectedMenuItem);        if (!currentChild) {            m_currentlySelectedMenuItem = nullptr;            currentChild = children.get();        }        // Repeating characters should iterate.        if (repeatingCharacter) {            if (GList* nextChild = g_list_next(currentChild))                currentChild = nextChild;        }    }    GList* firstChild = currentChild;    do {        currentChild = g_list_next(currentChild);        if (!currentChild)            currentChild = children.get();        GUniquePtr<gchar> itemText(g_utf8_casefold(gtk_menu_item_get_label(GTK_MENU_ITEM(currentChild->data)), -1));        if (!strncmp(searchStringWithCaseFolded.get(), itemText.get(), prefixLength)) {            gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), GTK_WIDGET(currentChild->data));            break;        }    } while (currentChild != firstChild);    return true;}

void dev_select_rescan(GtkAction *action, GtkWindow *parent){	GtkComboBox *dev = g_object_get_data(G_OBJECT(parent), "devcombo");	g_return_if_fail(dev != NULL);	GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(dev));	GtkTreeIter iter;	struct sr_device *device;	struct sr_device_instance *sdi;	gchar *sdevname = NULL;	GSList *devices, *l;	GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager");	GtkWidget *menuitem = gtk_ui_manager_get_widget(ui,					"/menubar/DevMenu/DevSelectMenu");	GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem)));	GSList *radiolist = NULL;	(void)action;	/* Make a copy of the selected device's short name for comparison.	 * We wish to select the same device after the refresh if possible.	 */	if (gtk_combo_box_get_active_iter(dev, &iter)) {		gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &device, -1);		/* FIXME: Use something other than device->plugin->name */		sdevname = g_strdup(device->plugin->name);	}	/* Destroy the old menu items */	if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do {		GtkMenuItem *item;		gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1);		gtk_object_destroy(GTK_OBJECT(item));	} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter));	gtk_list_store_clear(devlist);	/* Scan for new devices and update our list */	/* TODO: Fix this in libsigrok first. */	/*sr_device_scan();*/	devices = sr_device_list();	for (l = devices; l; l = l->next) {		device = l->data;		sdi = GET_DEVICE_INSTANCE(device);		gchar *name = sdi->model ? sdi->model : sdi->vendor;		if (!name)			name = "(unknown)";		menuitem = gtk_radio_menu_item_new_with_label(radiolist, name);		gtk_widget_show(GTK_WIDGET(menuitem));		if (!radiolist)			radiolist = gtk_radio_menu_item_get_group(					GTK_RADIO_MENU_ITEM(menuitem));		g_signal_connect(menuitem, "toggled",				G_CALLBACK(dev_menuitem_toggled), dev);		gtk_menu_shell_prepend(devmenu, menuitem);		gtk_list_store_append(devlist, &iter);		gtk_list_store_set(devlist, &iter,				0, name,				1, device,				2, menuitem,				-1);		if (sdevname && g_str_equal(sdevname, device->plugin->name))			gtk_combo_box_set_active_iter(dev, &iter);	}	if (sdevname)		g_free(sdevname);	/* Select a default if nothing selected */	if (!gtk_combo_box_get_active_iter(dev, &iter)) {		if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter))			return;		/* Skip demo if there's another available */		GtkTreeIter first = iter;		if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter))			gtk_combo_box_set_active_iter(dev, &iter);		else			gtk_combo_box_set_active_iter(dev, &first);	}}

struct menu *gui_gtk_menu_new(struct container *co, GtkWidget **widget){	struct menu *this=g_new0(struct menu, 1);	this->gui=g_new0(struct menu_gui,1);        this->gui->co=co;	GtkWidget *menu,*item,*menu2,*item2,*menu3,*clock;	menu=gtk_menu_bar_new();	item=gtk_menu_item_new_with_label("Goto");	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);	{		menu2=gtk_menu_new();		item2=gtk_menu_item_new_with_label("Abensberg");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_goto_abensberg), this);		item2=gtk_menu_item_new_with_label("Regensburg");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_goto_regensburg), this);		item2=gtk_menu_item_new_with_label("Problem");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_goto_problem), this);	}	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);	item=gtk_menu_item_new_with_label("Window");	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);	{		menu2=gtk_menu_new();		item2=gtk_menu_item_new_with_label("Clone");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_clone), this);		item2=gtk_menu_item_new_with_label("Command");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_command), this);		item2=gtk_menu_item_new_with_label("Visible Blocks");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_visible_blocks), co);		item2=gtk_menu_item_new_with_label("Visible Towns");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_visible_towns), co);		item2=gtk_menu_item_new_with_label("Visible Polys");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_visible_polys), co);		item2=gtk_menu_item_new_with_label("Visible Streets");		gtk_menu_append (GTK_MENU(menu2), item2);		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_window_visible_streets), co);		menu_item(this, menu2, "Visible Points", menu_window_visible_points);		item2=gtk_menu_item_new_with_label("Exit");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (exit), this);	}	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);	item=gtk_menu_item_new_with_label("Map");	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);	{		menu2=gtk_menu_new();		item2=gtk_menu_item_new_with_label("Compare");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_map_compare), this);		item2=gtk_menu_item_new_with_label("Distances");		gtk_menu_append (GTK_MENU(menu2), item2); 		gtk_signal_connect_object(GTK_OBJECT(item2), "activate",			GTK_SIGNAL_FUNC (menu_map_distances), this);	}	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu2);	item=gtk_menu_item_new_with_label("Route");	gtk_menu_bar_append(GTK_MENU_BAR(menu), item);	{		menu2=gtk_menu_new();		item2=gtk_menu_item_new_with_label("Start");//.........这里部分代码省略.........

static voidsensor_enabled(IsManager *manager,               IsSensor *sensor,               gint position,               IsIndicator *self){  IsIndicatorPrivate *priv = self->priv;  /* make sure we haven't seen this sensor before - if sensor has a   * menu-item then ignore it */  if (!g_object_get_data(G_OBJECT(sensor), "menu-item"))  {    GtkMenu *menu;    GtkWidget *menu_item;    is_debug("indicator", "Creating menu item for newly enabled sensor %s",             is_sensor_get_path(sensor));    g_signal_connect(sensor, "notify::value",                     G_CALLBACK(sensor_notify),                     self);    g_signal_connect(sensor, "notify::label",                     G_CALLBACK(sensor_notify),                     self);    g_signal_connect(sensor, "notify::alarmed",                     G_CALLBACK(sensor_notify),                     self);    g_signal_connect(sensor, "notify::low-value",                     G_CALLBACK(sensor_notify),                     self);    g_signal_connect(sensor, "notify::high-value",                     G_CALLBACK(sensor_notify),                     self);    /* add a menu entry for this sensor */    menu = is_indicator_get_menu(self);    menu_item = gtk_check_menu_item_new();    gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),                                          TRUE);    g_object_set_data(G_OBJECT(sensor), "menu-item", menu_item);    g_object_set_data(G_OBJECT(menu_item), "sensor", sensor);    priv->menu_items = g_slist_insert(priv->menu_items, menu_item,                                      position);    /* if we haven't seen our primary sensor yet or if this is the     * primary sensor, display this as primary anyway */    if (!priv->primary ||        g_strcmp0(is_sensor_get_path(sensor),                  priv->primary_sensor_path) == 0)    {      is_debug("indicator", "Using sensor with path %s as primary",               is_sensor_get_path(sensor));      if (priv->primary)      {        GtkCheckMenuItem *item;        /* uncheck menu item if exists for this         * existing primary sensor */        item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary),                                    "menu-item"));        if (item)        {          is_debug("indicator", "Unchecking current primary sensor item");          gtk_check_menu_item_set_active(item, FALSE);        }        g_object_unref(priv->primary);      }      priv->primary = g_object_ref(sensor);      is_debug("indicator", "Checking new primary sensor item");      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item),                                     TRUE);      update_sensor_menu_item_label(self, sensor,                                    GTK_MENU_ITEM(menu_item));    }    /* connect to toggled signal now - if we connect to it earlier     * we may interpret the above menu_item_set_active as a user     * initiated setting of the primary sensor rather than us just     * picking the first available sensor */    g_signal_connect(menu_item, "toggled",                     G_CALLBACK(sensor_menu_item_toggled),                     self);    gtk_widget_show_all(menu_item);    update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item));    gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, position);  }  else  {    is_debug("indicator", "Newly enabled sensor %s already has a menu-item, ignoring...",             is_sensor_get_path(sensor));  }}

voidadd_mainmenu_actions (GtkWidget *mainwin){    DB_plugin_t **plugins = deadbeef->plug_get_list();    int i;    for (i = 0; plugins[i]; i++)    {        if (!plugins[i]->get_actions)            continue;        DB_plugin_action_t *actions = plugins[i]->get_actions (NULL);        DB_plugin_action_t *action;        for (action = actions; action; action = action->next)        {            char *tmp = NULL;            if (0 == (action->flags & DB_ACTION_COMMON))                continue;            // 1st check if we have slashes            const char *slash = action->title;            while (NULL != (slash = strchr (slash, '/'))) {                if (slash && slash > action->title && *(slash-1) == '//') {                    slash++;                    continue;                }                break;            }            if (!slash) {                continue;            }            char *ptr = tmp = strdup (action->title);            char *prev_title = NULL;            GtkWidget *current = mainwin;            GtkWidget *previous;            while (1)            {                // find unescaped forward slash                char *slash = strchr (ptr, '/');                if (slash && slash > ptr && *(slash-1) == '//') {                    ptr = slash + 1;                    continue;                }                if (!slash)                {                    GtkWidget *actionitem;                    actionitem = gtk_image_menu_item_new_with_mnemonic (_(ptr));                    gtk_widget_show (actionitem);                    /* Here we have special cases for different submenus */                    if (0 == strcmp ("File", prev_title))                        gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 5);                    else if (0 == strcmp ("Edit", prev_title))                        gtk_menu_shell_insert (GTK_MENU_SHELL (current), actionitem, 7);                    else                        gtk_container_add (GTK_CONTAINER (current), actionitem);                    g_signal_connect ((gpointer) actionitem, "activate",                        G_CALLBACK (on_actionitem_activate),                        action);                    break;                }                *slash = 0;                char menuname [1024];                snprintf (menuname, sizeof (menuname), "%s_menu", ptr);                previous = current;                current = lookup_widget (current, menuname);                if (!current)                {                    GtkWidget *newitem;                    newitem = gtk_menu_item_new_with_mnemonic (ptr);                    gtk_widget_show (newitem);                    //If we add new submenu in main bar, add it before 'Help'                    if (NULL == prev_title)                        gtk_menu_shell_insert (GTK_MENU_SHELL (previous), newitem, 4);                    else                        gtk_container_add (GTK_CONTAINER (previous), newitem);                    current = gtk_menu_new ();                    gtk_menu_item_set_submenu (GTK_MENU_ITEM (newitem), current);                }                prev_title = ptr;                ptr = slash + 1;            }            if (tmp) {                free (tmp);            }        }    }}

void pMenu::setText(const string &text) {  gtk_menu_item_set_label(GTK_MENU_ITEM(widget), mnemonic(text));}

static void *gtk_thread(void *arg){	struct gtk_mod *mod = arg;	GtkMenuShell *app_menu;	GtkWidget *item;	GError *err = NULL;	struct le *le;	gdk_threads_init();	gtk_init(0, NULL);	g_set_application_name("baresip");	mod->app = g_application_new ("com.creytiv.baresip",			G_APPLICATION_FLAGS_NONE);	g_application_register (G_APPLICATION (mod->app), NULL, &err);	if (err != NULL) {		warning ("Unable to register GApplication: %s",				err->message);		g_error_free (err);		err = NULL;	}#ifdef USE_LIBNOTIFY	notify_init("baresip");#endif	mod->status_icon = gtk_status_icon_new_from_icon_name("call-start");	gtk_status_icon_set_tooltip_text (mod->status_icon, "baresip");	g_signal_connect(G_OBJECT(mod->status_icon),			"button_press_event",			G_CALLBACK(status_icon_on_button_press), mod);	gtk_status_icon_set_visible(mod->status_icon, TRUE);	mod->contacts_inited = false;	mod->dial_dialog = NULL;	mod->call_windows = NULL;	mod->incoming_call_menus = NULL;	/* App menu */	mod->app_menu = gtk_menu_new();	app_menu = GTK_MENU_SHELL(mod->app_menu);	/* Account submenu */	mod->accounts_menu = gtk_menu_new();	mod->accounts_menu_group = NULL;	item = gtk_menu_item_new_with_mnemonic("_Account");	gtk_menu_shell_append(app_menu, item);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),			mod->accounts_menu);	/* Add accounts to submenu */	for (le = list_head(uag_list()); le; le = le->next) {		struct ua *ua = le->data;		accounts_menu_add_item(mod, ua);	}	/* Status submenu */	mod->status_menu = gtk_menu_new();	item = gtk_menu_item_new_with_mnemonic("_Status");	gtk_menu_shell_append(GTK_MENU_SHELL(app_menu), item);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), mod->status_menu);	/* Open */	item = gtk_radio_menu_item_new_with_label(NULL, "Open");	g_object_set_data(G_OBJECT(item), "presence",			GINT_TO_POINTER(PRESENCE_OPEN));	g_signal_connect(item, "activate",			G_CALLBACK(menu_on_presence_set), mod);	gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item);	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);	/* Closed */	item = gtk_radio_menu_item_new_with_label_from_widget(			GTK_RADIO_MENU_ITEM(item), "Closed");	g_object_set_data(G_OBJECT(item), "presence",			GINT_TO_POINTER(PRESENCE_CLOSED));	g_signal_connect(item, "activate",			G_CALLBACK(menu_on_presence_set), mod);	gtk_menu_shell_append(GTK_MENU_SHELL(mod->status_menu), item);	gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new());	/* Dial */	item = gtk_menu_item_new_with_mnemonic("_Dial...");	gtk_menu_shell_append(app_menu, item);	g_signal_connect(G_OBJECT(item), "activate",			G_CALLBACK(menu_on_dial), mod);	/* Dial contact */	mod->contacts_menu = gtk_menu_new();	item = gtk_menu_item_new_with_mnemonic("Dial _contact");	gtk_menu_shell_append(app_menu, item);	gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),			mod->contacts_menu);	gtk_menu_shell_append(app_menu, gtk_separator_menu_item_new());	/* About *///.........这里部分代码省略.........

WAttGtk::WAttGtk( 	GtkWidget      	*wa_parent_wid,	void 		*wa_parent_ctx, 	ldh_tSesContext wa_ldhses, 	pwr_sAttrRef 	wa_aref,	int 		wa_editmode,	int 		wa_advanced_user,	int		wa_display_objectname) :  WAtt(wa_parent_ctx,wa_ldhses,wa_aref,wa_editmode,wa_advanced_user,       wa_display_objectname), parent_wid(wa_parent_wid){  int sts;  int size;  char *namep;  sts = ldh_AttrRefToName( ldhses, &aref, ldh_eName_Hierarchy, 			   &namep, &size);  if ( EVEN(sts)) return;  toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 					 "default-height", 570,					 "default-width", 410,					 "title", CoWowGtk::convert_utf8(namep),					 NULL);  g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);  g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);  g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);  CoWowGtk::SetWindowIcon( toplevel);  GtkWidget *vbox = gtk_vbox_new( FALSE, 0);  // Menu  // Accelerators  GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);  gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);  GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);  // File entry  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);  g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);  GtkWidget *file_print = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, accel_g);  g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);  GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));  // Functions entry  GtkWidget *func_changevalue = gtk_menu_item_new_with_mnemonic( "_Change Value");  g_signal_connect( func_changevalue, "activate", 		    G_CALLBACK(activate_change_value), this);  gtk_widget_add_accelerator( func_changevalue, "activate", accel_g,			      'q', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);  GtkWidget *func_close_changeval = gtk_menu_item_new_with_mnemonic( "C_lose Change Value");  g_signal_connect( func_close_changeval, "activate", 		    G_CALLBACK(activate_close_changeval), this);  gtk_widget_add_accelerator( func_close_changeval, "activate", accel_g,			      't', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);  GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);  gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_changevalue);  gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_close_changeval);  GtkWidget *functions = gtk_menu_item_new_with_mnemonic("_Functions");  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);  gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));  // Help entry  GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);  g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);  GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);  gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);  GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);  gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));  pane = gtk_vpaned_new();  if ( ((WUtility *)parent_ctx)->utype == wb_eUtility_WNav)    parent_ctx = ((WNav *)parent_ctx)->parent_ctx;  utility = ((WUtility *)parent_ctx)->utype;    wattnav = new WAttNavGtk( (void *)this, wattnav_eType_Object, pane, "Plant",			      ldhses, aref, wa_editmode, wa_advanced_user,			      wa_display_objectname, utility, &brow_widget, &sts);  ((WAttNav *)wattnav)->message_cb = &WAtt::message_cb;  ((WAttNav *)wattnav)->change_value_cb = &WAtt::change_value_cb;    GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);//.........这里部分代码省略.........