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

static voidseach_entry_populate_popup (GtkEntry *entry, PraghaPreferences *preferences){	GtkWidget *popup_menu, *item;	gboolean instant_search, approximate_search;	popup_menu = gtk_menu_new ();	/* Instant search. */	item = gtk_check_menu_item_new_with_label (_("Refine the search while writing"));	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);	instant_search = pragha_preferences_get_instant_search(preferences);	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), instant_search);	g_signal_connect (G_OBJECT (item), "toggled",				G_CALLBACK (search_entry_instant_option_toggled), preferences);	gtk_widget_show (item);	/* Aproximate search. */	item = gtk_check_menu_item_new_with_label (_("Search approximate words"));	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);	approximate_search = pragha_preferences_get_approximate_search(preferences);	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), approximate_search);	g_signal_connect (G_OBJECT (item), "toggled",				G_CALLBACK (search_entry_approximate_option_toggled), preferences);	gtk_widget_show (item);	gtk_menu_attach_to_widget(GTK_MENU(popup_menu), GTK_WIDGET(entry), NULL);	gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL,			(GtkMenuPositionFunc) menu_position, entry,			0, gtk_get_current_event_time());}

static void _e2_option_sel_activated_cb (GtkMenuItem *menu_item, E2_OptionSet *set){	GtkWidget *controller = g_object_get_data (G_OBJECT (menu_item),		"e2-controller-widget");	if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (controller),		"e2-controller-blocked")))			return;	if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_item)))		return;//	NEEDCLOSEBGL	GSList *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));//	NEEDOPENBGL	gint index = 2 - g_slist_index (group, menu_item);	e2_option_sel_set_direct (set, index);}

static voidadd_popup_menu_items (GtkWidget      *menu,                      GeditViewFrame *frame){	GtkWidget *menu_item;	/* create "Wrap Around" menu item. */	menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around"));	g_signal_connect (G_OBJECT (menu_item), "toggled",			  G_CALLBACK (wrap_around_menu_item_toggled),			  frame);	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),					frame->priv->wrap_around);	gtk_widget_show (menu_item);	/* create "Match Entire Word Only" menu item. */	menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only"));	g_signal_connect (G_OBJECT (menu_item), "toggled",			  G_CALLBACK (match_entire_word_menu_item_toggled),			  frame);	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),					GEDIT_SEARCH_IS_ENTIRE_WORD (frame->priv->search_flags));	gtk_widget_show (menu_item);	/* create "Match Case" menu item. */	menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case"));	g_signal_connect (G_OBJECT (menu_item), "toggled",			  G_CALLBACK (match_case_menu_item_toggled),			  frame);	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),					GEDIT_SEARCH_IS_CASE_SENSITIVE (frame->priv->search_flags));	gtk_widget_show (menu_item);}

static voidactivate_cb(GtkWidget *w, JamDoc *doc) {	const gchar *user;	JamAccount *acc = jam_doc_get_account(doc);	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w)))		return;	user = gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));	if (g_ascii_strcasecmp(user, jam_account_get_username(acc)) == 0)		user = NULL; /* post as normal user. */	jam_doc_set_usejournal(doc, user);}

void toggle_chat_window(gpointer data, guint action, GtkWidget * w){	ChatWidgets *list;	for (list = chats; list; list = list->next) {		if (!list->container)			continue;		if (GTK_CHECK_MENU_ITEM(w)->active) {			gtk_widget_show(list->container);		} else {			gtk_widget_hide(list->container);		}	}}

static GtkWidget *build_port_menu(void){	gint i;	GtkWidget *item;	GdkPixmap *pixmap;	GtkWidget *image;	GtkWidget *menu;	MapTheme *theme = theme_get_current();	menu = gtk_menu_new();	for (i = 0; i <= ANY_RESOURCE; i++) {		item =		    gtk_image_menu_item_new_with_mnemonic(gettext							  (port_names[i]));		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);		g_signal_connect(G_OBJECT(item), "activate",				 G_CALLBACK(select_port_resource_cb),				 GINT_TO_POINTER(i));		pixmap = theme->port_tiles[i];		if (i >= NO_RESOURCE || pixmap == NULL)			continue;		image = gtk_image_new_from_pixmap(pixmap, NULL);		gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),					      image);	}	gtk_menu_shell_append(GTK_MENU_SHELL(menu),			      gtk_separator_menu_item_new());	for (i = 0; i < 6; i++) {		item =		    gtk_check_menu_item_new_with_label(Q_						       (port_direction_names							[i]));		gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM						      (item), TRUE);		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);		g_signal_connect(G_OBJECT(item), "toggled",				 G_CALLBACK(select_port_direction_cb),				 GINT_TO_POINTER(i));		port_directions[i] = item;	}	gtk_widget_show_all(menu);	return menu;}

/* Create and show the popup menu */static void show_popup_menu(TilemDisasmView *dv, GdkEventButton *event){	GtkWidget *menu, *item;	dword curpos;	if (dv->popup_menu)		gtk_widget_destroy(dv->popup_menu);	dv->popup_menu = menu = gtk_menu_new();	/* Enable/disable breakpoint */	item = gtk_check_menu_item_new_with_mnemonic(_("_Breakpoint Here"));	get_cursor_line(dv, &curpos, NULL);	if (curpos == (dword) -1)		gtk_widget_set_sensitive(item, FALSE);	else if (find_line_bp(dv, curpos))		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);	g_signal_connect(item, "toggled",	                 G_CALLBACK(toggle_bp), dv);	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);	gtk_widget_show(item);	item = gtk_separator_menu_item_new();	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);	gtk_widget_show(item);	/* Jump to address */	item = gtk_menu_item_new_with_mnemonic(_("_Go to Address..."));	g_signal_connect(item, "activate", G_CALLBACK(prompt_go_to), dv);	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);	gtk_widget_show(item);	item = gtk_menu_item_new_with_mnemonic(_("Go to P_C"));	g_signal_connect(item, "activate", G_CALLBACK(go_to_pc), dv);	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);	gtk_widget_show(item);	if (event)		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,		               event->button, event->time);	else		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, &place_menu, dv,		               0, gtk_get_current_event_time());}

static void check_rotation_menu_item(struct screen_info *info,        xcb_randr_rotation_t rotation, gboolean is_active){    GtkWidget *item = info->rotation_menu_items[rotation];    if (!item) {        g_warning("Unknown rotation item/n");        return;    }    g_signal_handlers_block_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item),            (gpointer)info);    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), is_active);    g_signal_handlers_unblock_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item),            (gpointer)info);}

void      explorer_force_pause           (Explorer *self){    /* Force rendering to pause now, but keep note of its original state     * so that explorer_restore_pause() can undo this as necessary.     */    GtkCheckMenuItem *paused = GTK_CHECK_MENU_ITEM(glade_xml_get_widget(self->xml, "pause_menu"));    gboolean original_state = gtk_check_menu_item_get_active(paused);    gtk_check_menu_item_set_active(paused, TRUE);    /* Now, on_pause_rendering_toggle just disabled unpause_on_restore since     * typically only a user changes the pause_menu state. We want to turn     * that back on if we just paused it and originally it was unpaused,     * so that explorer_restore_pause() does the Right Thing (tm).     */    self->unpause_on_restore = !original_state;}

voidgnc_split_reg2_double_line_cb (GtkWidget *w, gpointer data){    GNCSplitReg2 *gsr = data;    GncTreeModelSplitReg *model = gnc_ledger_display2_get_split_model_register (gsr->ledger);    gboolean use_double_line;    use_double_line = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (w));    if (use_double_line == model->use_double_line)        return;    gnc_tree_model_split_reg_config (model, model->type, model->style, use_double_line);    // This will re-display the view.    gnc_tree_view_split_reg_set_format (gnc_ledger_display2_get_split_view_register (gsr->ledger));}

void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data){	GtkTreeViewColumn *col;	show_range = GTK_CHECK_MENU_ITEM(menuitem)->active;	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NO);	if (col)		gtk_tree_view_column_set_visible(col, show_range);	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_MOD);	if (col)		gtk_tree_view_column_set_visible(col, show_range);	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_YES);	if (col)		gtk_tree_view_column_set_visible(col, show_range);}

G_MODULE_EXPORT gbooleanon_winMain_delete_event(void){	/* return false to allow destroy */	if(#ifdef CFG_USE_RADIO			gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chkTray))#else			gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(chkTray))#endif			){		tray_toggle();		return TRUE;	}	return FALSE;}

int main(int argc,char *argv[]){    GtkWidget *window;    GtkWidget *vbox;    GtkWidget *menubar;    GtkWidget *viewmenu;    GtkWidget *view;    GtkWidget *tog_stat;    GtkWidget *statusbar;    gtk_init(&argc,&argv);    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);    gtk_window_set_default_size(GTK_WINDOW(window),250,200);    gtk_window_set_title(GTK_WINDOW(window),"view statusbar");    vbox = gtk_vbox_new(FALSE,0);    gtk_container_add(GTK_CONTAINER(window),vbox);    menubar = gtk_menu_bar_new();    viewmenu = gtk_menu_new();    view = gtk_menu_item_new_with_label("View");    tog_stat = gtk_check_menu_item_new_with_label("View Statusbar");    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat),TRUE);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(view),viewmenu);    gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu),tog_stat);    gtk_menu_shell_append(GTK_MENU_SHELL(menubar),view);    gtk_box_pack_start(GTK_BOX(vbox),menubar,FALSE,FALSE,3);    statusbar = gtk_statusbar_new();    gtk_box_pack_end(GTK_BOX(vbox),statusbar,FALSE,TRUE,1);    g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);    g_signal_connect(G_OBJECT(tog_stat),"activate",G_CALLBACK(toggle_statusbar),statusbar);    gtk_widget_show_all(window);    gtk_main();    return 0;}

staticGtkWidget *convert_menu(const struct PP_Flash_Menu *pp_menu){    GtkWidget *menu = gtk_menu_new();    for (uintptr_t k = 0; k < pp_menu->count; k ++) {        const struct PP_Flash_MenuItem pp_mi = pp_menu->items[k];        GtkWidget *mi = NULL;        switch (pp_mi.type) {        case PP_FLASH_MENUITEM_TYPE_NORMAL:            mi = gtk_menu_item_new_with_label(pp_mi.name);            break;        case PP_FLASH_MENUITEM_TYPE_CHECKBOX:            mi = gtk_check_menu_item_new_with_label(pp_mi.name);            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), pp_mi.checked != PP_FALSE);            break;        case PP_FLASH_MENUITEM_TYPE_SEPARATOR:            mi = gtk_separator_menu_item_new();            break;        case PP_FLASH_MENUITEM_TYPE_SUBMENU:            mi = gtk_menu_item_new_with_label(pp_mi.name);            break;        }        if (!mi)            continue;        gtk_widget_set_sensitive(mi, pp_mi.enabled != PP_FALSE);        gtk_widget_show(mi);        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);        if (pp_mi.type == PP_FLASH_MENUITEM_TYPE_SUBMENU) {            gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi), convert_menu(pp_mi.submenu));        } else {            // each menu item have specific id associated            g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_item_activated),                             (void*)(size_t)pp_mi.id);            // connect "button-press-event" to workaround submenu "activate" signal missing issue            g_signal_connect(G_OBJECT(mi), "button-press-event", G_CALLBACK(menu_item_button_press),                             (void*)(size_t)pp_mi.id);        }    }    return menu;}

void termit_on_switch_page(GtkNotebook *notebook, gpointer arg, guint page, gpointer user_data){    TERMIT_GET_TAB_BY_INDEX(pTab, page);    TRACE("%s page=%d vte=%p", __FUNCTION__, page, pTab->vte);    // it seems that set_active eventually calls toggle callback    /*((GtkCheckMenuItem*)termit.mi_show_scrollbar)->active = pTab->scrollbar_is_shown;*/    gpointer pHandlerId = g_object_get_data(G_OBJECT(termit.mi_show_scrollbar), "handlerId");    if (pHandlerId) {        g_signal_handler_disconnect(G_OBJECT(termit.mi_show_scrollbar), *((gulong*)pHandlerId));    }    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(termit.mi_show_scrollbar), pTab->scrollbar_is_shown);    termit_set_show_scrollbar_signal(termit.mi_show_scrollbar, pHandlerId);    termit_set_statusbar_message(page);    if (configs.allow_changing_title)        termit_set_window_title(pTab->title);}

static void on_widget_toggle(GtkWidget *widget, Explorer* self){    /* Toggle visibility of another widget. This widget should be named     * toggle_foo to control the visibility of a widget named foo.     */    const gchar *name;    GtkWidget *toggled;    name = gtk_widget_get_name(widget);    g_assert(!strncmp((void *) name, "toggle_", 7));    toggled = glade_xml_get_widget(self->xml, name+7);    if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))	gtk_widget_show(toggled);    else	gtk_widget_hide(toggled);}

voidon_toggle_status_bar_activate          (GtkMenuItem     *menuitem,                                        gpointer         user_data){    GtkWidget *sb = lookup_widget (mainwin, "statusbar");    if (sb) {        if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem))) {            deadbeef->conf_set_int ("gtkui.statusbar.visible", 0);            gtk_widget_hide (sb);        }        else {            deadbeef->conf_set_int ("gtkui.statusbar.visible", 1);            gtk_widget_show (sb);        }    }    deadbeef->sendmessage (DB_EV_CONFIGCHANGED, 0, 0, 0);}

static void dev_menuitem_toggled(GtkMenuItem *item, GtkComboBox *combo){	GtkTreeModel *model = gtk_combo_box_get_model(combo);	GtkTreeIter iter;	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item)))		return;		if (gtk_tree_model_get_iter_first(model, &iter)) do {		gchar *name;		gtk_tree_model_get(model, &iter, 0, &name, -1);		if (g_str_equal(name, gtk_menu_item_get_label(item))) {			gtk_combo_box_set_active_iter(combo, &iter);			return;		}	} while (gtk_tree_model_iter_next(model, &iter));}

static voidremmina_icon_populate_additional_menu_item (GtkWidget *menu){    GtkWidget *menuitem;    menuitem = gtk_image_menu_item_new_with_label (_("Open Main Window"));    gtk_widget_show (menuitem);    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),        gtk_image_new_from_icon_name ("remmina", GTK_ICON_SIZE_MENU));    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_main), NULL);    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_PREFERENCES, NULL);    gtk_widget_show (menuitem);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_preferences), NULL);    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);    gtk_widget_show (menuitem);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_about), NULL);    menuitem = gtk_separator_menu_item_new ();    gtk_widget_show (menuitem);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);#ifdef HAVE_LIBAVAHI_CLIENT    menuitem = gtk_check_menu_item_new_with_label (_("Enable Service Discovery"));    if (remmina_pref.applet_enable_avahi)    {        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);    }    gtk_widget_show (menuitem);    g_signal_connect (G_OBJECT (menuitem), "toggled", G_CALLBACK (remmina_icon_enable_avahi), NULL);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);#endif    menuitem = gtk_separator_menu_item_new ();    gtk_widget_show (menuitem);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);    menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);    gtk_widget_show (menuitem);    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);    g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (remmina_icon_destroy), NULL);}

static void menu_setting_foreach(void (*callback) (window_t *), int id, guint state) {	int maindone = FALSE;	/* do it only once for EVERY tab */	window_t *w;	for (w = windows; w; w = w->next) {		gtk_window_ui_t *gui = gtk_private_ui(w);		if (!gui->is_tab || !maindone) {			if (gui->is_tab)				maindone = TRUE;			if (id != -1)				GTK_CHECK_MENU_ITEM(gui->menu_item[id])->active = state;			if (callback)				callback(w);		}	}}

int main(int argc, char *argv[]){  QwertickleGUI* gui = g_new0(QwertickleGUI, 1);  gst_init(NULL, NULL);  gtk_init(&argc, &argv);  gui->statusicon = gtk_status_icon_new_from_file(DATADIR"/qwertickle.png");  gtk_status_icon_set_visible(gui->statusicon, TRUE);  gui->mainmenu = GTK_MENU(gtk_menu_new());  gui->play = GTK_MENU_ITEM(gtk_menu_item_new());  gui->sep = GTK_SEPARATOR_MENU_ITEM(gtk_separator_menu_item_new());  gui->quit =    GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-quit", NULL));  gui->about =    GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_from_stock("gtk-about", NULL));  gui->enable =    GTK_CHECK_MENU_ITEM(gtk_check_menu_item_new_with_label("Enable"));  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->enable));  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->about));  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->sep));  gtk_menu_shell_append(GTK_MENU_SHELL(gui->mainmenu), GTK_WIDGET(gui->quit));  /* initialize widgets */  gtk_check_menu_item_set_active(gui->enable, TRUE);  /* connect signals */  g_signal_connect(gui->statusicon, "popup-menu", G_CALLBACK(on_menu_pop), gui);  g_signal_connect(gui->enable, "toggled", G_CALLBACK(on_enable_toggled), gui);  g_signal_connect(gui->quit, "activate", G_CALLBACK(on_quit_activate), gui);  g_signal_connect(gui->about, "activate", G_CALLBACK(on_about_activate), gui);  g_signal_connect(gui->play, "activate", G_CALLBACK(on_play_activate), NULL);  gtk_widget_show_all(GTK_WIDGET(gui->mainmenu));  /* Fix freezing bug? close stdout and stdin so Xorg won't have to process   * the input to stdout when program exit*/  close(0);  close(1);  pthread_create(&thread, NULL, intercept_key_thread, gui->play);  gtk_main();  return 0;}

G_MODULE_EXPORT void on_statistics_pane1_activate(GtkWidget *wiggy, gpointer data){	GtkWidget *w;	w=GTK_WIDGET(gtk_builder_get_object (builder, "StatisticsPane"));	if(w==NULL)		fprintf(stderr,"Cannot get the statistics pane./n");	else {		switch(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wiggy))) {			case 0:				gtk_widget_hide(w);				break;			default:				gtk_widget_show(w);		}	}}

static voidoverview_ui_add_menu_item (void){  static const gchar *view_menu_name = "menu_view1_menu";  static const gchar *prev_item_name = "menu_show_sidebar1";  GtkWidget          *main_window = geany_data->main_widgets->window;  GtkWidget          *view_menu;  GtkWidget          *prev_item;  gint                item_pos;  gboolean            visible = FALSE;  view_menu = ui_lookup_widget (main_window, view_menu_name);  if (! GTK_IS_MENU (view_menu))    {      g_critical ("failed to locate the View menu (%s) in Geany's main menu",                  view_menu_name);      return;    }  overview_ui_menu_item = gtk_check_menu_item_new_with_label (_("Show Overview"));  prev_item = ui_lookup_widget (main_window, prev_item_name);  if (! GTK_IS_MENU_ITEM (prev_item))    {      g_critical ("failed to locate the Show Sidebar menu item (%s) in Geany's UI",                  prev_item_name);      overview_ui_menu_sep = gtk_separator_menu_item_new ();      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_sep);      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_item);      gtk_widget_show (overview_ui_menu_sep);    }  else    {      item_pos = overview_ui_get_menu_item_pos (view_menu, prev_item);      overview_ui_menu_sep = NULL;      gtk_menu_shell_insert (GTK_MENU_SHELL (view_menu), overview_ui_menu_item, item_pos);    }  g_object_get (overview_ui_prefs, "visible", &visible, NULL);  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (overview_ui_menu_item), visible);  g_object_bind_property (overview_ui_menu_item, "active",                          overview_ui_prefs, "visible",                          G_BINDING_DEFAULT);  gtk_widget_show (overview_ui_menu_item);}

/* There are two activatable widgets, a toggle button and a menu item. * * If a widget is activated and the state of the tool button is the same as * the new state of the activated widget, then the other widget was the one * that was activated by the user and updated the tool button's state. * * If the state of the tool button is not the same as the new state of the * activated widget, then the activation was activated by the user, and the * widget needs to make sure the tool button is updated before the other * widget is activated. This will make sure the other widget a tool button * in a state that matches its own new state. */static voidmenu_item_activated (GtkWidget           *menu_item,		     GtkToggleToolButton *toggle_tool_button){  GtkToolButton *tool_button = GTK_TOOL_BUTTON (toggle_tool_button);  gboolean menu_active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_item));  if (toggle_tool_button->priv->active != menu_active)    {      toggle_tool_button->priv->active = menu_active;      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_tool_button_get_button (tool_button)),				    toggle_tool_button->priv->active);      g_object_notify (G_OBJECT (toggle_tool_button), "active");      g_signal_emit (toggle_tool_button, toggle_signals[TOGGLED], 0);    }}

void menu_info_subitem_update(menu_info_t* mi, uint32_t index, const char* name,        const char* desc, char* tooltip, const char* icon){    menu_info_item_t* item = menu_info_item_get(mi, index);   if(item == NULL)       g_error("[menu_info] subitem not found!");    gboolean active = mi->parent->target == index;    g_debug("[menu_info] updating subitem %s %u '%s' %s", menu_info_type_name(mi->type),            index, desc, active ? " (active)" : "");    if(!g_str_equal(item->desc, desc))        gtk_menu_item_set_label(GTK_MENU_ITEM(item->widget), desc);    if(active)        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->widget), TRUE);}

void cwiid_acc(struct cwiid_acc_mesg *mesg){	static gchar str[LBLVAL_LEN];	double a_x, a_y, a_z, a;	double roll, pitch;		if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(chkAcc))) {		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_X]);		gtk_label_set_text(GTK_LABEL(lblAccXVal), str);		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccX),		                              (double)mesg->acc[CWIID_X]/0xFF);		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Y]);		gtk_label_set_text(GTK_LABEL(lblAccYVal), str);		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccY),		                              (double)mesg->acc[CWIID_Y]/0xFF);		g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Z]);		gtk_label_set_text(GTK_LABEL(lblAccZVal), str);		gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccZ),		                              (double)mesg->acc[CWIID_Z]/0xFF);		a_x = ((double)mesg->acc[CWIID_X] - wm_cal.zero[CWIID_X]) /		      (wm_cal.one[CWIID_X] - wm_cal.zero[CWIID_X]);		a_y = ((double)mesg->acc[CWIID_Y] - wm_cal.zero[CWIID_Y]) /		      (wm_cal.one[CWIID_Y] - wm_cal.zero[CWIID_Y]);		a_z = ((double)mesg->acc[CWIID_Z] - wm_cal.zero[CWIID_Z]) /		      (wm_cal.one[CWIID_Z] - wm_cal.zero[CWIID_Z]);		a = sqrt(pow(a_x,2)+pow(a_y,2)+pow(a_z,2));		roll = atan(a_x/a_z);		if (a_z <= 0.0) {			roll += PI * ((a_x > 0.0) ? 1 : -1);		}		roll *= -1;		pitch = atan(a_y/a_z*cos(roll));		g_snprintf(str, LBLVAL_LEN, "%.2f", a);		gtk_label_set_text(GTK_LABEL(lblAccVal), str);		g_snprintf(str, LBLVAL_LEN, "%.2f", roll);		gtk_label_set_text(GTK_LABEL(lblRollVal), str);		g_snprintf(str, LBLVAL_LEN, "%.2f", pitch);		gtk_label_set_text(GTK_LABEL(lblPitchVal), str);	}}

void sc_gui_update_menu(void){    GtkWidget *menu_item;    guint i;    static gboolean need_init = TRUE;    GSList *group = NULL;    gchar *label;    if (need_init)    {        gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), sc_info->menu_item);        need_init = FALSE;    }    if (sc_info->main_menu != NULL)        gtk_widget_destroy(sc_info->main_menu);    sc_info->main_menu = gtk_menu_new();    gtk_menu_item_set_submenu(GTK_MENU_ITEM(sc_info->menu_item), sc_info->main_menu);    sc_info->submenu_item_default = gtk_menu_item_new_with_label(NULL);    gtk_container_add(GTK_CONTAINER(sc_info->main_menu), sc_info->submenu_item_default);    g_signal_connect(sc_info->submenu_item_default, "activate",                     G_CALLBACK(menu_item_toggled_cb), NULL);    update_labels();    menu_item = gtk_separator_menu_item_new();    gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);    sc_ignore_callback = TRUE;    for (i = 0; i < sc_info->dicts->len; i++)    {        label = g_ptr_array_index(sc_info->dicts, i);        menu_item = gtk_radio_menu_item_new_with_label(group, label);        group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));        if (utils_str_equal(sc_info->default_language, label))            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE);        gtk_container_add(GTK_CONTAINER(sc_info->main_menu), menu_item);        g_signal_connect(menu_item, "toggled", G_CALLBACK(menu_item_toggled_cb), label);    }    sc_ignore_callback = FALSE;    gtk_widget_show_all(sc_info->main_menu);}

voidviewer_load_preferences (Viewer *viewer, const char *fname){    GKeyFile *preferences = g_key_file_new ();    int loaded = 0;    if (g_file_test (fname, G_FILE_TEST_IS_REGULAR)) {        loaded = g_key_file_load_from_file (preferences, fname, 0, NULL);    }    if (!loaded) goto done;    dbg ("loading viewer settings from %s/n", fname);            for (int ridx = 0; ridx < viewer->renderers->len; ridx++) {        Renderer *renderer = g_ptr_array_index (viewer->renderers, ridx);        GtkCheckMenuItem *cmi = GTK_CHECK_MENU_ITEM (renderer->cmi);        GError *err = NULL;        int enabled = g_key_file_get_boolean (preferences,                "__libviewer_enabled_renderers", renderer->name, &err);        if (err) {            err ("%s/n", err->message);            g_error_free (err);        } else {            gtk_check_menu_item_set_active (cmi, enabled);        }        if (renderer->widget) {            if (g_key_file_has_key (preferences, "__libviewer_show_renderers",                         renderer->name, NULL)) {                renderer->expanded = g_key_file_get_boolean (preferences,                         "__libviewer_show_renderers", renderer->name, NULL);                gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander),                        renderer->expanded);            }        }    }    g_signal_emit (G_OBJECT(viewer), viewer_signals[LOAD_PREFERENCES_SIGNAL], 0,            preferences);done:    g_key_file_free (preferences);}

/** * nma_utils_update_password_storage: * @passwd_entry: #GtkEntry with the password * @secret_flags: secret flags to set * @setting: #NMSetting containing the password, or NULL * @password_flags_name: name of the secret flags (like psk-flags), or NULL * * Updates secret flags in the password storage popup menu and also * in the @setting (if @setting and @password_flags_name are not NULL). * */voidnma_utils_update_password_storage (GtkWidget *passwd_entry,                                   NMSettingSecretFlags secret_flags,                                   NMSetting *setting,                                   const char *password_flags_name){    GList *menu_list, *iter;    GtkWidget *menu = NULL;    /* Update secret flags (WEP_KEY_FLAGS, PSK_FLAGS, ...) in the security setting */    if (setting && password_flags_name)        nm_setting_set_secret_flags (setting, password_flags_name, secret_flags, NULL);    /* Update password-storage popup menu to reflect secret flags */    menu_list = gtk_menu_get_for_attach_widget (passwd_entry);    for (iter = menu_list; iter; iter = g_list_next (iter)) {        if (g_object_get_data (G_OBJECT (iter->data), PASSWORD_STORAGE_MENU_TAG)) {            menu = iter->data;            break;        }    }    if (menu) {        GtkRadioMenuItem *item;        MenuItem idx;        GSList *group;        gboolean with_not_required;        int i, last;        /* radio menu group list contains the menu items in reverse order */        item = (GtkRadioMenuItem *) gtk_menu_get_active (GTK_MENU (menu));        group = gtk_radio_menu_item_get_group (item);        with_not_required = !!g_object_get_data (G_OBJECT (menu), MENU_WITH_NOT_REQUIRED_TAG);        idx = secret_flags_to_menu_item (secret_flags, with_not_required);        last = g_slist_length (group) - idx - 1;        for (i = 0; i < last; i++)            group = g_slist_next (group);        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (group->data), TRUE);        change_password_storage_icon (passwd_entry, idx);    }}