static void gtk_radio_menu_item_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkRadioMenuItem *radio_menu_item; radio_menu_item = GTK_RADIO_MENU_ITEM (object); switch (prop_id) { GSList *slist; case PROP_GROUP: if (G_VALUE_HOLDS_OBJECT (value)) slist = gtk_radio_menu_item_get_group ((GtkRadioMenuItem*) g_value_get_object (value)); else slist = NULL; gtk_radio_menu_item_set_group (radio_menu_item, slist); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void populate_menu (charpick_data *curr_data) { GList *list = curr_data->chartable; GSList *group = NULL; GtkMenu *menu; GtkWidget *menuitem; if (curr_data->menu) gtk_widget_destroy (curr_data->menu); curr_data->menu = gtk_menu_new (); menu = GTK_MENU (curr_data->menu); while (list) { gchar *string = list->data; menuitem = gtk_radio_menu_item_new_with_label (group, string); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_widget_show (menuitem); g_object_set_data (G_OBJECT (menuitem), "string", string); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (menuitem_activated), curr_data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); if (g_ascii_strcasecmp (curr_data->charlist, string) == 0) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE); list = g_list_next (list); } build_table(curr_data); }
static GtkMenuItem *accounts_menu_add_item(struct gtk_mod *mod, struct ua *ua) { GtkMenuShell *accounts_menu = GTK_MENU_SHELL(mod->accounts_menu); GtkWidget *item; GSList *group = mod->accounts_menu_group; struct ua *ua_current = uag_current(); char buf[256]; re_snprintf(buf, sizeof buf, "%s%s", ua_aor(ua), ua_isregistered(ua) ? " (OK)" : ""); item = gtk_radio_menu_item_new_with_label(group, buf); group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM (item)); if (ua == ua_current) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); g_object_set_data(G_OBJECT(item), "ua", ua); g_signal_connect(item, "toggled", G_CALLBACK(menu_on_account_toggled), mod); gtk_menu_shell_append(accounts_menu, item); mod->accounts_menu_group = group; return GTK_MENU_ITEM(item); }
/* Get the type of view (3D, 3D flat or 2D) */ void change_perspective(GtkWidget *widget, gpointer data) { GSList *list; const gchar *label; list = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM(data)); while(list) { if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) { label = gtk_menu_item_get_label(GTK_MENU_ITEM(widget)); list = NULL; if (strcmp(label, "2D (D)") == 0) { viewType = TWO_D; } else { if (strcmp(label, "3D (D)") == 0){ viewType = THREE_D; } else { viewType = THREE_D_FLAT; } } newEvent = TRUE; } else { list = g_slist_next(list); } } }
static void board_window_rebuild_board_menu (window_board_t *win) { if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (win->board_menu))) gtk_menu_item_remove_submenu (GTK_MENU_ITEM (win->board_menu)); GtkWidget *submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (win->board_menu), submenu); int i; GSList *group = NULL; for (i = 0; i < win->n_boards; i++) { board *b = win->boards[i]; GString *label = g_string_new (b->name->str); g_string_append_printf (label, " (%s)", contract_string (b->level, b->trumps, b->declarer, b->doubled)); GtkWidget *menuitem = gtk_radio_menu_item_new_with_label (group, label->str); g_string_free (label, TRUE); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); if (i == win->cur) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (board_menu_select), &(win->board_numbers[i])); /* pointer to array index */ gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem); gtk_widget_show (menuitem); } }
static GtkWidget *radio_menu_item_new(GSList **group, const gchar *name) { GtkWidget *menu_item = gtk_radio_menu_item_new_with_mnemonic(*group, name); *group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item)); return menu_item; }
gboolean mt_ctw_init (MTClosure *mt, gint x, gint y) { GtkWidget *ctw, *w; GError *error = NULL; const gchar *b[] = { "single", "double", "drag", "right" }; GSList *group; gpointer data; gint i; mt->ui = gtk_builder_new (); gtk_builder_add_from_file (mt->ui, DATADIR "/mousetweaks.ui", &error); if (error) { g_print ("%s\n", error->message); g_error_free (error); g_object_unref (mt->ui); mt->ui = NULL; return FALSE; } ctw = mt_ctw_get_window (mt); gtk_window_stick (GTK_WINDOW (ctw)); gtk_window_set_keep_above (GTK_WINDOW (ctw), TRUE); g_signal_connect (ctw, "delete-event", G_CALLBACK (ctw_delete_cb), mt); for (i = 0; i < N_CLICK_TYPES; i++) { w = WID (b[i]); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE); g_signal_connect (w, "toggled", G_CALLBACK (ctw_button_cb), mt); g_signal_connect (w, "button-press-event", G_CALLBACK (ctw_context_menu), mt); } g_signal_connect (WID ("text"), "toggled", G_CALLBACK (ctw_menu_toggled), mt); g_signal_connect (WID ("icon"), "toggled", G_CALLBACK (ctw_menu_toggled), mt); w = WID ("both"); g_signal_connect (w, "toggled", G_CALLBACK (ctw_menu_toggled), mt); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w)); data = g_slist_nth_data (group, mt->style); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (data), TRUE); gtk_widget_realize (ctw); mt_ctw_update_style (mt, mt->style); mt_ctw_update_sensitivity (mt); mt_ctw_update_visibility (mt); if (x != -1 && y != -1) gtk_window_move (GTK_WINDOW (ctw), x, y); return TRUE; }
/** * nma_utils_setup_password_storage: * @passwd_entry: password #GtkEntry which the icon is attached to * @initial_flags: initial secret flags to setup password menu from * @setting: #NMSetting containing the password, or NULL * @password_flags_name: name of the secret flags (like psk-flags), or NULL * @with_not_required: whether to include "Not required" menu item * @ask_mode: %TRUE if the entrie is shown in ASK mode. That means, * while prompting for a password, contrary to being inside the * editor mode. * If %TRUE, the entry should be sensivive on selected "always-ask" * icon (this is e.f. for nm-applet asking for password), otherwise * not. * If %TRUE, it shall not be possible to select a different storage, * because we only prompt for a password, we cannot change the password * location. * * Adds a secondary icon and creates a popup menu for password entry. * The active menu item is set up according to initial_flags, or * from @setting/@password_flags_name (if they are not NULL). * If the @setting/@password_flags_name are not NULL, secret flags will * be automatically updated in the setting when menu is changed. */ void nma_utils_setup_password_storage (GtkWidget *passwd_entry, NMSettingSecretFlags initial_flags, NMSetting *setting, const char *password_flags_name, gboolean with_not_required, gboolean ask_mode) { GtkWidget *popup_menu; GtkWidget *item[4]; GSList *group; MenuItem idx; NMSettingSecretFlags secret_flags; /* Whether entry should be sensitive if "always-ask" is active " */ g_object_set_data (G_OBJECT (passwd_entry), ASK_MODE_TAG, GUINT_TO_POINTER (ask_mode)); popup_menu = gtk_menu_new (); g_object_set_data (G_OBJECT (popup_menu), PASSWORD_STORAGE_MENU_TAG, GUINT_TO_POINTER (TRUE)); g_object_set_data (G_OBJECT (popup_menu), MENU_WITH_NOT_REQUIRED_TAG, GUINT_TO_POINTER (with_not_required)); group = NULL; item[0] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[0])); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item[0])); item[1] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[1])); item[2] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[2])); if (with_not_required) item[3] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[3])); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[0]); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[1]); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[2]); if (with_not_required) gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[3]); popup_menu_item_info_register (item[0], setting, password_flags_name, ITEM_STORAGE_USER, passwd_entry); popup_menu_item_info_register (item[1], setting, password_flags_name, ITEM_STORAGE_SYSTEM, passwd_entry); popup_menu_item_info_register (item[2], setting, password_flags_name, ITEM_STORAGE_ASK, passwd_entry); if (with_not_required) popup_menu_item_info_register (item[3], setting, password_flags_name, ITEM_STORAGE_UNUSED, passwd_entry); g_signal_connect (passwd_entry, "icon-release", G_CALLBACK (icon_release_cb), popup_menu); gtk_entry_set_icon_activatable (GTK_ENTRY (passwd_entry), GTK_ENTRY_ICON_SECONDARY, !ask_mode); gtk_menu_attach_to_widget (GTK_MENU (popup_menu), passwd_entry, NULL); /* Initialize active item for password-storage popup menu */ if (setting && password_flags_name) nm_setting_get_secret_flags (setting, password_flags_name, &secret_flags, NULL); else secret_flags = initial_flags; idx = secret_flags_to_menu_item (secret_flags, with_not_required); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item[idx]), TRUE); change_password_storage_icon (passwd_entry, idx); }
static gboolean add_item_cb (PluginHandle * plugin, IfaceMenuAddState * state) { GtkWidget * item = gtk_radio_menu_item_new_with_label (state->group, aud_plugin_get_name (plugin)); state->group = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *) item); if (aud_plugin_get_enabled (plugin)) gtk_check_menu_item_set_active ((GtkCheckMenuItem *) item, TRUE); gtk_menu_shell_append ((GtkMenuShell *) state->menu, item); g_signal_connect (item, "activate", (GCallback) switch_cb, plugin); gtk_widget_show (item); return TRUE; }
void systray_remove_radio_item(menu_info_t* mi, GtkWidget* item) { gtk_radio_menu_item_set_group(GTK_RADIO_MENU_ITEM(item), NULL); gtk_container_remove(GTK_CONTAINER(mi->menu), item); /* update group */ GList* children = gtk_container_get_children(GTK_CONTAINER(mi->menu)); if(children) mi->group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(children->data)); else mi->group = NULL; }
/** * gtk_radio_menu_item_new_from_widget: * @group: An existing #GtkRadioMenuItem * * Creates a new #GtkRadioMenuItem adding it to the same group as @group. * * Return value: The new #GtkRadioMenuItem * * Since: 2.4 **/ GtkWidget * gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group) { GSList *list = NULL; g_return_val_if_fail (GTK_IS_RADIO_MENU_ITEM (group), NULL); if (group) list = gtk_radio_menu_item_get_group (group); return gtk_radio_menu_item_new (list); }
/** * gtk_radio_menu_item_new_with_label_from_widget: * @group: an existing #GtkRadioMenuItem * @label: the text for the label * * Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. * The new #GtkRadioMenuItem is added to the same group as @group. * * Return value: The new #GtkRadioMenuItem * * Since: 2.4 **/ GtkWidget * gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group, const gchar *label) { GSList *list = NULL; g_return_val_if_fail (GTK_IS_RADIO_MENU_ITEM (group), NULL); if (group) list = gtk_radio_menu_item_get_group (group); return gtk_radio_menu_item_new_with_label (list, label); }
static gboolean player_av_button_press (GtkWidget *da, GdkEventButton *event, PlayerAV *self) { GdkRectangle rect; GdkScreen *screen = gdk_screen_get_default (); gint num = gdk_screen_get_n_monitors (screen); if (self->priv->monitor >= num) { self->priv->monitor = num-1; } if (event->button == 3) { GtkWidget *item; GtkWidget *menu = gtk_menu_new (); item = gtk_menu_item_new_with_label ("Toggle Fullscreen"); gtk_menu_append (GTK_MENU (menu), item); g_signal_connect (item, "activate", G_CALLBACK (toggle_fullscreen), self); gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ()); GSList *group = NULL; gint i; for (i = 0; i < num; i++) { gdk_screen_get_monitor_geometry (screen, i, &rect); gchar *str = g_strdup_printf ("%d: %dx%d", i+1, rect.width, rect.height); item = gtk_radio_menu_item_new_with_label (group, str); g_free (str); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); if (i == self->priv->monitor) { gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE); } gtk_menu_append (GTK_MENU (menu), item); g_signal_connect (item, "activate", G_CALLBACK (on_pick_screen), self); } gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ()); gtk_widget_show_all (menu); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, event->button, event->time); } else if (event->type == GDK_2BUTTON_PRESS) { toggle_fullscreen (NULL, self); } return FALSE; }
static void ctw_menu_toggled (GtkCheckMenuItem *item, gpointer data) { MTClosure *mt = data; GSList *group; gint index; if (!gtk_check_menu_item_get_active (item)) return; group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); index = g_slist_index (group, item); gconf_client_set_int (mt->client, OPT_STYLE, index, NULL); }
static VALUE rmitem_set_group(VALUE self, VALUE grp_ary) { GtkRadioMenuItem *rmitem2add, *rmitem_orig; GSList *group; rmitem2add = GTK_RADIO_MENU_ITEM(RVAL2GOBJ(self)); rmitem_orig = GTK_RADIO_MENU_ITEM(RVAL2GOBJ(rb_ary_entry(grp_ary, 0))); group = gtk_radio_menu_item_group(rmitem_orig); gtk_radio_menu_item_set_group(rmitem2add, group); return GSLIST2ARY(gtk_radio_menu_item_get_group(rmitem2add)); }
GtkWidget* create_menu_item( GtkAction* action ) { GtkWidget* item = 0; if ( IS_EGE_SELECT_ONE_ACTION(action) ) { EgeSelectOneAction* act = EGE_SELECT_ONE_ACTION( action ); gchar* sss = 0; gint index = 0; GtkTreeIter iter; GSList* group = 0; GtkWidget* subby = gtk_menu_new(); g_object_get( G_OBJECT(action), "label", &sss, NULL ); item = gtk_menu_item_new_with_label( sss ); gboolean valid = gtk_tree_model_get_iter_first( act->private_data->model, &iter ); while ( valid ) { gchar* str = 0; gtk_tree_model_get( act->private_data->model, &iter, act->private_data->labelColumn, &str, -1 ); GtkWidget *item = gtk_radio_menu_item_new_with_label( group, str ); group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(item) ); gtk_menu_shell_append( GTK_MENU_SHELL(subby), item ); g_object_set_qdata( G_OBJECT(item), gDataName, act ); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), index == act->private_data->active ); g_free(str); str = 0; g_signal_connect( G_OBJECT(item), "toggled", G_CALLBACK(menu_toggled_cb), GINT_TO_POINTER(index) ); index++; valid = gtk_tree_model_iter_next( act->private_data->model, &iter ); } gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby ); gtk_widget_show_all( subby ); g_free(sss); } else { item = GTK_ACTION_CLASS(ege_select_one_action_parent_class)->create_menu_item( action ); } return item; }
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 GtkWidget* make_radio_menu_item (WindowAction action, GSList **group, const gchar *mnemonic_text) { GtkWidget *mi; mi = gtk_radio_menu_item_new_with_mnemonic (*group, mnemonic_text); *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (mi)); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (item_activated_callback), GINT_TO_POINTER (action)); gtk_widget_show (mi); return mi; }
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); }
static VALUE rmitem_initialize(int argc, VALUE *argv, VALUE self) { VALUE arg1, arg2, arg3; GtkWidget *widget; GSList *list = NULL; const gchar *label = NULL; const gchar *mnemonic = NULL; if (rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3) > 0 && TYPE(arg1) == T_STRING) { if (NIL_P(arg2) || RVAL2CBOOL(arg2)) mnemonic = RVAL2CSTR(arg1); else label = RVAL2CSTR(arg1); } else { if (!NIL_P(arg2)) { if (NIL_P(arg3) || RVAL2CBOOL(arg3)) mnemonic = RVAL2CSTR(arg2); else label = RVAL2CSTR(arg2); } if (rb_obj_is_kind_of(arg1, GTYPE2CLASS(GTK_TYPE_RADIO_MENU_ITEM))) list = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(RVAL2GOBJ(arg1))); else if (TYPE(arg1) == T_ARRAY) /* TODO: This might leak. */ list = RVAL2GTKRADIOMENUITEMGSLIST(arg1); else if (!NIL_P(arg1)) rb_raise(rb_eArgError, "invalid argument %s (expect Array or Gtk::RadioMenuItem)", rb_class2name(CLASS_OF(arg1))); } if (label != NULL) widget = gtk_radio_menu_item_new_with_label(list, label); else if (mnemonic != NULL) widget = gtk_radio_menu_item_new_with_mnemonic(list, mnemonic); else widget = gtk_radio_menu_item_new(list); RBGTK_INITIALIZE(self, widget); return Qnil; }
GtkWidget* systray_add_radio_item(menu_info_item_t* mii, const char* tooltip) { menu_info_t* mi = mii->menu_info; gchar* label = menu_info_item_label(mii); GtkWidget* item = gtk_radio_menu_item_new_with_label(mi->group, label); g_free(label); if(tooltip) systray_set_tooltip(item, tooltip); mi->group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); systray_remove_placeholder(mi); gtk_menu_shell_append(mi->menu, item); gtk_widget_show(item); return item; }
void viewer_add_render_mode(Viewer *viewer, int mode, const char *name) { struct ViewerMode *m = (struct ViewerMode*) calloc(1, sizeof(struct ViewerMode)); m->mode = mode; m->name = strdup(name); m->menu_item = GTK_MENU_ITEM(gtk_radio_menu_item_new_with_label(viewer->modes_group, m->name)); g_ptr_array_add(viewer->modes, m); gtk_menu_shell_append(GTK_MENU_SHELL (viewer->mode_menu), GTK_WIDGET(m->menu_item)); if (g_ptr_array_size(viewer->modes) == 1) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(m->menu_item), TRUE); viewer->modes_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(m->menu_item)); gtk_widget_show(GTK_WIDGET(m->menu_item)); g_signal_connect(G_OBJECT(m->menu_item), "activate", G_CALLBACK (on_mode_change), viewer); }
/** * 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); } }
static GtkWidget * menu_radio_item(char *label, GtkWidget *menu, void *callback, void *userdata, int state, char *groupname) { GtkWidget *item; GtkMenuItem *parent; GSList *grouplist = NULL; parent = menu_find_item(menu, groupname); if (parent) grouplist = gtk_radio_menu_item_get_group((GtkRadioMenuItem *) parent); item = gtk_radio_menu_item_new_with_label(grouplist, label); gtk_check_menu_item_set_active((GtkCheckMenuItem *) item, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(callback), userdata); gtk_widget_show(item); return item; }
void populate_menu (charpick_data *curr_data) { GList *list = curr_data->chartable; GSList *group = NULL; GtkMenu *menu; GtkWidget *menuitem; if (curr_data->menu) gtk_widget_destroy (curr_data->menu); curr_data->menu = gtk_menu_new (); menu = GTK_MENU (curr_data->menu); while (list) { gchar *string = list->data; menuitem = gtk_radio_menu_item_new_with_label (group, string); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_widget_show (menuitem); g_object_set_data (G_OBJECT (menuitem), "string", string); g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (menuitem_activated), curr_data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); if (g_ascii_strcasecmp (curr_data->charlist, string) == 0) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE); list = g_list_next (list); } build_table(curr_data); /*Set up custom theme and transparency support*/ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu)); /* Fix any failures of compiz/other wm's to communicate with gtk for transparency */ GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel)); GdkVisual *visual = gdk_screen_get_rgba_visual(screen); gtk_widget_set_visual(GTK_WIDGET(toplevel), visual); /* Set menu and it's toplevel window to follow panel theme */ GtkStyleContext *context; context = gtk_widget_get_style_context (GTK_WIDGET(toplevel)); gtk_style_context_add_class(context,"gnome-panel-menu-bar"); gtk_style_context_add_class(context,"mate-panel-menu-bar"); }
extern void set_compatibility_menu(gtk_widgets_t *data, char *version) { GSList *g = NULL; version_e v = parse_version(version); for (version_e i = VERSION_CURRENT; i > VERSION_UNKNOWN; i--) { const char *t = get_version_string(i); GtkWidget *m = gtk_radio_menu_item_new_with_label(g, t); g = gtk_radio_menu_item_get_group((GtkRadioMenuItem *)m); gtk_menu_shell_append((GtkMenuShell *)data->compat_menu, m); g_signal_connect(G_OBJECT(m), "toggled", G_CALLBACK(on_compatibility_change), data); gtk_widget_show(m); if (i == v || i == VERSION_CURRENT) { gtk_check_menu_item_set_active((GtkCheckMenuItem *)m, TRUE); _version = i; } } return; }
GtkWidget* systray_add_radio_item(menu_info_t* mi, const char* desc, const char* tooltip) { GtkWidget* item = gtk_radio_menu_item_new_with_label(mi->group, desc); if(tooltip) systray_set_tooltip(item, tooltip); mi->group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); /* if this is the first item, remove the "none" placeholder label */ if(g_hash_table_size(mi->items) == 0) { GList* children = gtk_container_get_children(GTK_CONTAINER(mi->menu)); if(children) gtk_container_remove(GTK_CONTAINER(mi->menu), GTK_WIDGET(children->data)); } gtk_menu_shell_append(mi->menu, item); gtk_widget_show(item); return item; }
GtkWidget* create_toolbar_button_menu () { GtkWidget *menu = gtk_menu_new (); GSList *group = NULL; gint i = 0; ToolBarButtonMenuItemStruct *item = &items_array[i]; while (item->menu_item_label != NULL) { GtkRadioMenuItem *radio_item; radio_item = GTK_RADIO_MENU_ITEM (gtk_radio_menu_item_new_with_label (group, item->menu_item_label)); g_object_set_data (G_OBJECT (radio_item), TOOL_BAR_MENU_ITEM_STRUCT_PTR, item); group = gtk_radio_menu_item_get_group (radio_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), GTK_WIDGET (radio_item)); item = &items_array[++i]; }; gtk_widget_show_all (menu); return menu; }
static GtkWidget * create_menu (gint depth, gboolean tearoff) { GtkWidget *menu; GtkWidget *menuitem; GSList *group; char buf[32]; int i, j; if (depth < 1) return NULL; menu = gtk_menu_new (); group = NULL; if (tearoff) { menuitem = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } for (i = 0, j = 1; i < 5; i++, j++) { sprintf (buf, "item %2d - %d", depth, j); menuitem = gtk_radio_menu_item_new_with_label (group, buf); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); if (i == 3) gtk_widget_set_sensitive (menuitem, FALSE); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE)); } return menu; }
static GtkRadioMenuItem * create_zoom_menu_item (NautilusZoomControl *zoom_control, GtkMenu *menu, NautilusZoomLevel zoom_level, GtkRadioMenuItem *previous_radio_item) { GtkWidget *menu_item; char *item_text; GSList *radio_item_group; int percent; /* Set flag so that callback isn't activated when set_active called * to set toggle state of other radio items. */ zoom_control->details->marking_menu_items = TRUE; percent = floor ((100.0 * nautilus_get_relative_icon_size_for_zoom_level (zoom_level)) + .5); item_text = g_strdup_printf ("%d%%", percent); radio_item_group = previous_radio_item == NULL ? NULL : gtk_radio_menu_item_get_group (previous_radio_item); menu_item = gtk_radio_menu_item_new_with_label (radio_item_group, item_text); g_free (item_text); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), zoom_level == zoom_control->details->zoom_level); g_object_set_data (G_OBJECT (menu_item), "zoom_level", GINT_TO_POINTER (zoom_level)); g_signal_connect_object (menu_item, "activate", G_CALLBACK (zoom_menu_callback), zoom_control, 0); gtk_widget_show (menu_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); zoom_control->details->marking_menu_items = FALSE; return GTK_RADIO_MENU_ITEM (menu_item); }