static void seach_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 void add_popup_menu_items (GtkWidget *menu, GeditViewFrame *frame) { GtkWidget *menu_item; /* create "Wrap Around" menu item. */ menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around")); g_signal_connect (G_OBJECT (menu_item), "toggled", G_CALLBACK (wrap_around_menu_item_toggled), frame); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), frame->priv->wrap_around); gtk_widget_show (menu_item); /* create "Match Entire Word Only" menu item. */ menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only")); g_signal_connect (G_OBJECT (menu_item), "toggled", G_CALLBACK (match_entire_word_menu_item_toggled), frame); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), GEDIT_SEARCH_IS_ENTIRE_WORD (frame->priv->search_flags)); gtk_widget_show (menu_item); /* create "Match Case" menu item. */ menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case")); g_signal_connect (G_OBJECT (menu_item), "toggled", G_CALLBACK (match_case_menu_item_toggled), frame); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), GEDIT_SEARCH_IS_CASE_SENSITIVE (frame->priv->search_flags)); gtk_widget_show (menu_item); }
static void activate_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; }
void gnc_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 gboolean on_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; }
static GtkWidget * 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); }
void on_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 void gtk_check_menu_item_activate (GtkMenuItem *menu_item) { GtkCheckMenuItemPrivate *priv; GtkCheckMenuItem *check_menu_item = GTK_CHECK_MENU_ITEM (menu_item); priv = check_menu_item->priv; priv->active = !priv->active; gtk_check_menu_item_toggled (check_menu_item); gtk_widget_queue_draw (GTK_WIDGET (check_menu_item)); GTK_MENU_ITEM_CLASS (gtk_check_menu_item_parent_class)->activate (menu_item); g_object_notify (G_OBJECT (check_menu_item), "active"); }
static void remmina_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 void overview_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 void menu_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); }
void viewer_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). * */ void nma_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); } }