Example #1
0
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;
    }
}
Example #2
0
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);
}
Example #3
0
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);
}
Example #4
0
/* 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);
		}
	}	
}
Example #5
0
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);
	}
}
Example #6
0
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;
}
Example #7
0
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);
}
Example #9
0
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;
}
Example #10
0
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;
}
Example #11
0
/**
 * 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);
}
Example #12
0
/**
 * 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);
}
Example #13
0
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;
}
Example #14
0
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;
}
Example #17
0
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);
}
Example #18
0
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;
}
Example #19
0
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;
}
Example #21
0
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;
}
Example #22
0
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);
    }
}
Example #24
0
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;
}
Example #25
0
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");
}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
0
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;
}
Example #29
0
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);
}