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

static const gchar *descriptor_name (gint val){  GEnumValue *en;  en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek          (GST_TYPE_MPEG_TS_DESCRIPTOR_TYPE)), val);  if (en == NULL)    /* Else try with DVB enum types */    en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek            (GST_TYPE_MPEG_TS_DVB_DESCRIPTOR_TYPE)), val);  if (en == NULL)    /* Else try with ATSC enum types */    en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek            (GST_TYPE_MPEG_TS_ATSC_DESCRIPTOR_TYPE)), val);  if (en == NULL)    /* Else try with ISB enum types */    en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek            (GST_TYPE_MPEG_TS_ISDB_DESCRIPTOR_TYPE)), val);  if (en == NULL)    /* Else try with misc enum types */    en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek            (GST_TYPE_MPEG_TS_MISC_DESCRIPTOR_TYPE)), val);  if (en == NULL)    return "UNKNOWN/PRIVATE";  return en->value_nick;}

/** * atk_state_type_for_name: * @name: a character string state name * * Gets the #AtkStateType corresponding to the description string @name. * * Returns: an #AtkStateType corresponding to @name  */AtkStateTypeatk_state_type_for_name (const gchar *name){  GTypeClass *type_class;  GEnumValue *value;  AtkStateType type = ATK_STATE_INVALID;  g_return_val_if_fail (name, ATK_STATE_INVALID);  type_class = g_type_class_ref (ATK_TYPE_STATE_TYPE);  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), ATK_STATE_INVALID);  value = g_enum_get_value_by_nick (G_ENUM_CLASS (type_class), name);  if (value)    {      type = value->value;    }  else    {      gint i;      for (i = ATK_STATE_LAST_DEFINED + 1; i <= last_type; i++)        {          if (state_names[i] == NULL)            continue;           if (!strcmp(name, state_names[i]))             {              type = i;              break;            }        }    }  return type;}

static voidpreferences_widget_sync_string (const gchar *key, GtkWidget *widget){	gchar *value;	if (empathy_conf_get_string (empathy_conf_get (), key, &value) && value) {		if (GTK_IS_ENTRY (widget)) {			gtk_entry_set_text (GTK_ENTRY (widget), value);		} else if (GTK_IS_RADIO_BUTTON (widget)) {			if (strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {				GType        type;				GEnumClass  *enum_class;				GEnumValue  *enum_value;				GSList      *list;				GtkWidget   *toggle_widget;								/* Get index from new string */				type = empathy_contact_list_store_sort_get_type ();				enum_class = G_ENUM_CLASS (g_type_class_peek (type));				enum_value = g_enum_get_value_by_nick (enum_class, value);								if (enum_value) { 					list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));					toggle_widget = g_slist_nth_data (list, enum_value->value);					gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_widget), TRUE);				}			} else {				g_warning ("Unhandled key:'%s' just had string change", key);			}		}		g_free (value);	}}

static GVariant*infinoted_plugin_dbus_perms_to_variant(const InfAclMask* mask,                                       const InfAclMask* perms){  GVariantBuilder builder;  GEnumClass* enum_class;  guint i;  enum_class = G_ENUM_CLASS(g_type_class_ref(INF_TYPE_ACL_SETTING));  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sb}"));  for(i = 0; i < enum_class->n_values; ++i)  {    if(inf_acl_mask_has(mask, enum_class->values[i].value))    {      g_variant_builder_add(        &builder,        "{sb}",        enum_class->values[i].value_nick,        inf_acl_mask_has(perms, enum_class->values[i].value)      );    }  }  g_type_class_unref(enum_class);  return g_variant_builder_end(&builder);}

/** * atk_state_type_get_name: * @type: The #AtkStateType whose name is required * * Gets the description string describing the #AtkStateType @type. * * Returns: the string describing the AtkStateType */const gchar*atk_state_type_get_name (AtkStateType type){  GTypeClass *type_class;  GEnumValue *value;  const gchar *name = NULL;  type_class = g_type_class_ref (ATK_TYPE_STATE_TYPE);  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), NULL);  value = g_enum_get_value (G_ENUM_CLASS (type_class), type);  if (value)    {      name = value->value_nick;    }  else    {      if (type <= last_type)        {          if (type >= 0)            name = state_names[type];        }    }  return name;}

static voidmain_window_notify_sort_contact_cb (EmpathyConf       *conf,				    const gchar       *key,				    EmpathyMainWindow *window){	gchar *str = NULL;	if (empathy_conf_get_string (conf, key, &str) && str) {		GType       type;		GEnumClass *enum_class;		GEnumValue *enum_value;		type = empathy_contact_list_store_sort_get_type ();		enum_class = G_ENUM_CLASS (g_type_class_peek (type));		enum_value = g_enum_get_value_by_nick (enum_class, str);		if (enum_value) {			/* By changing the value of the GtkRadioAction,			   it emits a signal that calls main_window_view_sort_contacts_cb			   which updates the contacts list */			gtk_radio_action_set_current_value (window->sort_by_name,							    enum_value->value);		} else {			g_warning ("Wrong value for sort_criterium configuration : %s", str);		}		g_free (str);	}}

static voidmain_window_view_sort_contacts_cb (GtkRadioAction    *action,				   GtkRadioAction    *current,				   EmpathyMainWindow *window){	EmpathyContactListStoreSort value;	GSList      *group;	GType        type;	GEnumClass  *enum_class;	GEnumValue  *enum_value;	value = gtk_radio_action_get_current_value (action);	group = gtk_radio_action_get_group (action);	/* Get string from index */	type = empathy_contact_list_store_sort_get_type ();	enum_class = G_ENUM_CLASS (g_type_class_peek (type));	enum_value = g_enum_get_value (enum_class, g_slist_index (group, current));	if (!enum_value) {		g_warning ("No GEnumValue for EmpathyContactListSort with GtkRadioAction index:%d",			   g_slist_index (group, action));	} else {		empathy_conf_set_string (empathy_conf_get (),					 EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,					 enum_value->value_nick);	}	empathy_contact_list_store_set_sort_criterium (window->list_store, value);}

GVariant *photos_utils_create_zoom_target_value (gdouble delta, PhotosZoomEvent event){  GEnumClass *zoom_event_class = NULL; /* TODO: use g_autoptr */  GEnumValue *event_value;  GVariant *delta_value;  GVariant *event_nick_value;  GVariant *ret_val = NULL;  g_auto (GVariantBuilder) builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);  const gchar *event_nick = "none";  g_return_val_if_fail (delta >= 0.0, NULL);  g_return_val_if_fail (event != PHOTOS_ZOOM_EVENT_NONE, NULL);  delta_value = g_variant_new_double (delta);  g_variant_builder_add (&builder, "{sv}", "delta", delta_value);  zoom_event_class = G_ENUM_CLASS (g_type_class_ref (PHOTOS_TYPE_ZOOM_EVENT));  event_value = g_enum_get_value (zoom_event_class, (gint) event);  if (event_value != NULL)    event_nick = event_value->value_nick;  event_nick_value = g_variant_new_string (event_nick);  g_variant_builder_add (&builder, "{sv}", "event", event_nick_value);  ret_val = g_variant_builder_end (&builder);  g_type_class_unref (zoom_event_class);  g_return_val_if_fail (g_variant_is_floating (ret_val), ret_val);  return ret_val;}

PhotosZoomEventphotos_utils_get_zoom_event (GVariant *dictionary){  GEnumClass *zoom_event_class = NULL;  GEnumValue *event_value;  PhotosZoomEvent ret_val = PHOTOS_ZOOM_EVENT_NONE;  const gchar *event_str;  g_return_val_if_fail (dictionary != NULL, PHOTOS_ZOOM_EVENT_NONE);  g_return_val_if_fail (g_variant_is_of_type (dictionary, G_VARIANT_TYPE_VARDICT), PHOTOS_ZOOM_EVENT_NONE);  if (!g_variant_lookup (dictionary, "event", "&s", &event_str))    goto out;  zoom_event_class = G_ENUM_CLASS (g_type_class_ref (PHOTOS_TYPE_ZOOM_EVENT));  event_value = g_enum_get_value_by_nick (zoom_event_class, event_str);  if (event_value == NULL)    event_value = g_enum_get_value_by_name (zoom_event_class, event_str);  if (event_value == NULL)    goto out;  ret_val = (PhotosZoomEvent) event_value->value; out:  g_clear_pointer (&zoom_event_class, g_type_class_unref);  g_return_val_if_fail (ret_val != PHOTOS_ZOOM_EVENT_NONE, PHOTOS_ZOOM_EVENT_NONE);  return ret_val;}

/** * atk_relation_type_get_name: * @type: The #AtkRelationType whose name is required * * Gets the description string describing the #AtkRelationType @type. * * Returns: the string describing the AtkRelationType */const gchar*atk_relation_type_get_name (AtkRelationType type){  GTypeClass *type_class;  GEnumValue *value;  const gchar *name = NULL;  type_class = g_type_class_ref (ATK_TYPE_RELATION_TYPE);  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), NULL);  value = g_enum_get_value (G_ENUM_CLASS (type_class), type);  if (value)    {      name = value->value_nick;    }  else    {      if (extra_names)        {          gint n = type;          n -= ATK_RELATION_LAST_DEFINED + 1;          if (n < extra_names->len)            name = g_ptr_array_index (extra_names, n);        }    }  g_type_class_unref (type_class);  return name;}

/** * ges_transition_clip_new: * @vtype: the type of transition to create * * Creates a new #GESTransitionClip. * * Returns: a newly created #GESTransitionClip, or %NULL if something * went wrong. */GESTransitionClip *ges_transition_clip_new (GESVideoStandardTransitionType vtype){  GEnumValue *value;  GEnumClass *klass;  GESTransitionClip *ret = NULL;  klass =      G_ENUM_CLASS (g_type_class_ref (GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE));  if (!klass) {    GST_ERROR ("Could not find the StandarTransitionType enum class");    return NULL;  }  value = g_enum_get_value (klass, vtype);  if (!value) {    GST_ERROR ("Could not find enum value for %i", vtype);    return NULL;  }  ret = ges_transition_clip_new_for_nick (((gchar *) value->value_nick));  g_type_class_unref (klass);  return ret;}

intgo_conf_load_enum (GOConfNode *node, gchar const *key, GType t, int default_val){	int	 res;	gchar   *val_str = go_conf_load_string (node, key);	gboolean use_default = TRUE;	if (NULL != val_str) {		GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (t));		GEnumValue *enum_value = g_enum_get_value_by_nick (enum_class, val_str);		if (NULL == enum_value)			enum_value = g_enum_get_value_by_name (enum_class, val_str);		if (NULL != enum_value) {			use_default = FALSE;			res = enum_value->value;		} else {			g_warning ("Unknown value '%s' for %s", val_str, key);		}		g_type_class_unref (enum_class);		g_free (val_str);	}	if (use_default) {		d (g_warning ("Using default value '%d'", default_val));		return default_val;	}	return res;}

voidgo_conf_set_enum (GOConfNode *node, gchar const *key, GType t, gint val){	GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (t));	GEnumValue *enum_value = g_enum_get_value (enum_class, val);	go_conf_set_string (node, key, enum_value->value_nick);	g_type_class_unref (enum_class);}

/** * pyg_enum_get_value: * @enum_type: the GType of the flag. * @obj: a Python object representing the flag value * @val: a pointer to the location to store the integer representation of the flag. * * Converts a Python object to the integer equivalent.  The conversion * will depend on the type of the Python object.  If the object is an * integer, it is passed through directly.  If it is a string, it will * be treated as a full or short enum name as defined in the GType. * * Returns: 0 on success or -1 on failure */gintpyg_enum_get_value(GType enum_type, PyObject *obj, gint *val){    GEnumClass *eclass = NULL;    gint res = -1;    g_return_val_if_fail(val != NULL, -1);    if (!obj) {	*val = 0;	res = 0;    } else if (PYGLIB_PyLong_Check(obj)) {	*val = PYGLIB_PyLong_AsLong(obj);	res = 0;	if (PyObject_TypeCheck(obj, &PyGEnum_Type) && ((PyGEnum *) obj)->gtype != enum_type) {	    g_warning("expected enumeration type %s, but got %s instead",		      g_type_name(enum_type),		      g_type_name(((PyGEnum *) obj)->gtype));	}    /* Dumb code duplication, but probably not worth it to have yet another macro. */    } else if (PyLong_Check(obj)) {	*val = PyLong_AsLong(obj);	res = 0;	if (PyObject_TypeCheck(obj, &PyGEnum_Type) && ((PyGEnum *) obj)->gtype != enum_type) {	    g_warning("expected enumeration type %s, but got %s instead",		      g_type_name(enum_type),		      g_type_name(((PyGEnum *) obj)->gtype));	}    } else if (PYGLIB_PyUnicode_Check(obj)) {	GEnumValue *info;	char *str = PYGLIB_PyUnicode_AsString(obj);	if (enum_type != G_TYPE_NONE)	    eclass = G_ENUM_CLASS(g_type_class_ref(enum_type));	else {	    PyErr_SetString(PyExc_TypeError, "could not convert string to enum because there is no GType associated to look up the value");	    res = -1;	}	info = g_enum_get_value_by_name(eclass, str);	g_type_class_unref(eclass);	if (!info)	    info = g_enum_get_value_by_nick(eclass, str);	if (info) {	    *val = info->value;	    res = 0;	} else {	    PyErr_SetString(PyExc_TypeError, "could not convert string");	    res = -1;	}    } else {	PyErr_SetString(PyExc_TypeError,"enum values must be strings or ints");	res = -1;    }    return res;}

static const gchar *enum_name (GType instance_type, gint val){  GEnumValue *en;  en = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek (instance_type)), val);  if (!en)    return "UNKNOWN/PRIVATE";  return en->value_nick;}

const char *gss_program_state_get_name (GssProgramState state){  GEnumValue *ev;  ev = g_enum_get_value (G_ENUM_CLASS (g_type_class_peek          (gss_program_state_get_type ())), state);  if (ev == NULL)    return NULL;  return ev->value_name;}

static voidoutput_enum_values (GType class_type){	GEnumClass *eclass;	guint i;	eclass = G_ENUM_CLASS (g_type_class_peek (class_type));	for (i = 0; i < eclass->n_values; i++) {		GEnumValue *value = &(eclass->values[i]);		printf ("%s = %d;/n", value->value_name, value->value);	}}

static voidgst_fameenc_get_property (GObject * object, guint prop_id,    GValue * value, GParamSpec * pspec){  GstFameEnc *fameenc;  g_return_if_fail (GST_IS_FAMEENC (object));  fameenc = GST_FAMEENC (object);  switch (prop_id) {    case ARG_BITRATE:      g_value_set_int (value, fameenc->fp.bitrate);      break;    case ARG_QUALITY:      g_value_set_int (value, fameenc->fp.quality);      break;    case ARG_PATTERN:      g_value_set_string (value, fameenc->pattern);      break;    case ARG_FAME_VERBOSE:      g_value_set_boolean (value, fameenc->verbose);      break;    case ARG_BUFFER_SIZE:      g_value_set_int (value, fameenc->buffer_size);      break;    case ARG_FRAMES_PER_SEQUENCE:      g_value_set_int (value, fameenc->fp.frames_per_sequence);      break;    default:      if (prop_id >= ARG_FAME_PROPS_START) {        gchar *name;        gint index = 0;        GEnumValue *values;        fame_object_t *f_object;        values = G_ENUM_CLASS (g_type_class_ref (pspec->value_type))->values;        name = (gchar *) g_param_spec_get_qdata (pspec, fame_object_name);        f_object = fame_get_object (fameenc->fc, name);        while (values[index].value_name) {          if (!strcmp (values[index].value_nick, f_object->name)) {            g_value_set_enum (value, index);            return;          }          index++;        }      }      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;  }}

const static gchar*atspi_state_get_name (gint state){  GTypeClass *type_class;  GEnumValue *value;  type_class = g_type_class_ref (ATSPI_TYPE_STATE_TYPE);  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), "");  value = g_enum_get_value (G_ENUM_CLASS (type_class), state);  return value->value_nick;}

static gchar *owr_ice_state_get_name(OwrIceState state){    GEnumClass *enum_class;    GEnumValue *enum_value;    gchar *name;    enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_ICE_STATE));    enum_value = g_enum_get_value(enum_class, state);    name = g_strdup(enum_value ? enum_value->value_nick : "unknown");    g_type_class_unref(enum_class);    return name;}

static voidgst_fameenc_set_property (GObject * object, guint prop_id,    const GValue * value, GParamSpec * pspec){  GstFameEnc *fameenc;  g_return_if_fail (GST_IS_FAMEENC (object));  fameenc = GST_FAMEENC (object);  if (fameenc->initialized) {    GST_DEBUG        ("error: fameenc encoder already initialized, cannot set properties !");    return;  }  switch (prop_id) {    case ARG_BITRATE:      fameenc->fp.bitrate = g_value_get_int (value);      break;    case ARG_QUALITY:      fameenc->fp.quality = CLAMP (g_value_get_int (value), 0, 100);      break;    case ARG_PATTERN:      g_free (fameenc->pattern);      fameenc->pattern = g_strdup (g_value_get_string (value));      break;    case ARG_FAME_VERBOSE:      fameenc->verbose = g_value_get_boolean (value);      break;    case ARG_BUFFER_SIZE:      fameenc->buffer_size = g_value_get_int (value);      break;    case ARG_FRAMES_PER_SEQUENCE:      fameenc->fp.frames_per_sequence = g_value_get_int (value);      break;    default:      if (prop_id >= ARG_FAME_PROPS_START) {        gchar *name;        gint index = g_value_get_enum (value);        GEnumValue *values;        values = G_ENUM_CLASS (g_type_class_ref (pspec->value_type))->values;        name = (gchar *) g_param_spec_get_qdata (pspec, fame_object_name);        fame_register (fameenc->fc, name, fame_get_object (fameenc->fc,                values[index].value_name));      } else        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;  }}

static voidprint_enum (GType enum_type){  GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (enum_type));  guint i;  GST_ERROR ("%d", enum_class->n_values);  for (i = 0; i < enum_class->n_values; i++) {    g_printf ("%s/n", enum_class->values[i].value_nick);  }  g_type_class_unref (enum_class);}

static voidenum_pref_create_widget (GOConfNode *node, GtkWidget *grid,			 gint row, GType enum_type,			 enum_conf_setter_t setter,			 enum_conf_getter_t getter,			 gchar const *default_label,                         char const *(*label_getter)(int)){	unsigned int	 i;	GtkTreeIter	 iter;	GtkCellRenderer	*renderer;	GEnumClass	*enum_class = G_ENUM_CLASS (g_type_class_ref (enum_type));	GtkWidget	*combo = gtk_combo_box_new ();	GtkListStore	*model = gtk_list_store_new (2,		G_TYPE_STRING, G_TYPE_POINTER);	gint             current = getter ();	gint             current_index = -1;	for (i = 0; i < enum_class->n_values ; i++) {		gtk_list_store_append (model, &iter);		gtk_list_store_set (model, &iter,			0,	label_getter ((int) enum_class->values[i].value),			1,	enum_class->values + i,			-1);		if (enum_class->values[i].value == current)			current_index = i;	}	g_type_class_unref (enum_class);	gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (model));	g_object_unref (model);	renderer = gtk_cell_renderer_text_new ();	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 0, NULL);	gtk_combo_box_set_active (GTK_COMBO_BOX (combo), current_index);	gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1);	g_signal_connect (G_OBJECT (combo), "changed",		G_CALLBACK (cb_enum_changed), (gpointer) setter);	connect_notification (node, (GOConfMonitorFunc)enum_pref_conf_to_widget,			      combo, grid);	pref_create_label (node, grid, row, default_label, combo);	set_tip (node, combo);}

void PropertyEnum::build_widget(){	combobox = new QComboBox();	widget->layout()->addWidget(combobox);	GEnumValue *values;	guint j = 0;	values = G_ENUM_CLASS (g_type_class_ref(param_spec->value_type))->values;	while (values[j].value_name)	{		combobox->addItems({values[j].value_nick});		j++;	}	connect(combobox, SIGNAL(currentIndexChanged(int)), this, SLOT(update_position(int)));}

static gchar *enum_value_to_string (GType enum_type,                      gint  enum_value){  gpointer enum_class;  GEnumValue *val;  gchar* result;  g_assert (G_TYPE_IS_ENUM (enum_type));  enum_class = g_type_class_ref (enum_type);  val = g_enum_get_value (G_ENUM_CLASS (enum_class), enum_value);  result = g_strdup (val ? val->value_nick : "undefined");  g_type_class_unref (enum_class);  return result;}

inline static const gchar *verbosity_to_string (TrackerVerbosity verbosity){        GType type;        GEnumClass *enum_class;        GEnumValue *enum_value;        type = tracker_verbosity_get_type ();        enum_class = G_ENUM_CLASS (g_type_class_peek (type));        enum_value = g_enum_get_value (enum_class, verbosity);        if (!enum_value) {                return "unknown";        }        return enum_value->value_nick;}

EXPORT_C#endifvoidgst_object_default_deep_notify (GObject * object, GstObject * orig,    GParamSpec * pspec, gchar ** excluded_props){  GValue value = { 0, };        /* the important thing is that value.type = 0 */  gchar *str = NULL;  gchar *name = NULL;  if (pspec->flags & G_PARAM_READABLE) {    /* let's not print these out for excluded properties... */    while (excluded_props != NULL && *excluded_props != NULL) {      if (strcmp (pspec->name, *excluded_props) == 0)        return;      excluded_props++;    }    g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));    g_object_get_property (G_OBJECT (orig), pspec->name, &value);    /* FIXME: handle flags */    if (G_IS_PARAM_SPEC_ENUM (pspec)) {      GEnumValue *enum_value;      GEnumClass *klass = G_ENUM_CLASS (g_type_class_ref (pspec->value_type));      enum_value = g_enum_get_value (klass, g_value_get_enum (&value));      str = g_strdup_printf ("%s (%d)", enum_value->value_nick,          enum_value->value);      g_type_class_unref (klass);    } else {      str = g_strdup_value_contents (&value);    }    name = gst_object_get_path_string (orig);    g_print ("%s: %s = %s/n", name, pspec->name, str);    g_free (name);    g_free (str);    g_value_unset (&value);  } else {    name = gst_object_get_path_string (orig);    g_warning ("Parameter %s not readable in %s.", pspec->name, name);    g_free (name);  }}

static voidenum_modified (GtkToggleButton *button, ObjectProperty *p){  gint i;  GEnumClass *eclass;  GValue val = G_VALUE_INIT;  if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))    return;  eclass = G_ENUM_CLASS (g_type_class_peek (p->spec->value_type));  i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "index"));  g_value_init (&val, p->spec->value_type);  g_value_set_enum (&val, eclass->values[i].value);  set_property_value (p->obj, p->spec, &val);  g_value_unset (&val);}

/** * atk_relation_type_for_name: * @name: a string which is the (non-localized) name of an ATK relation type. * * Get the #AtkRelationType type corresponding to a relation name. * * Returns: the #AtkRelationType enumerated type corresponding to the specified name, *          or #ATK_RELATION_NULL if no matching relation type is found. **/AtkRelationTypeatk_relation_type_for_name (const gchar *name){  GTypeClass *type_class;  GEnumValue *value;  AtkRelationType type = ATK_RELATION_NULL;  g_return_val_if_fail (name, ATK_RELATION_NULL);  type_class = g_type_class_ref (ATK_TYPE_RELATION_TYPE);  g_return_val_if_fail (G_IS_ENUM_CLASS (type_class), ATK_RELATION_NULL);  value = g_enum_get_value_by_nick (G_ENUM_CLASS (type_class), name);  if (value)    {      type = value->value;    }  else    {      gint i;      if (extra_names)        {          for (i = 0; i < extra_names->len; i++)            {              gchar *extra_name = (gchar *)g_ptr_array_index (extra_names, i);              g_return_val_if_fail (extra_name, ATK_RELATION_NULL);                       if (strcmp (name, extra_name) == 0)                {                  type = i + 1 + ATK_RELATION_LAST_DEFINED;                  break;                }            }        }    }  g_type_class_unref (type_class);   return type;}

static gbooleaninfinoted_plugin_dbus_perms_from_variant(InfAclMask* mask,                                         InfAclMask* perms,                                         GVariant* variant,                                         GError** error){  GEnumClass* enum_class;  GEnumValue* val;  GVariantIter iter;  const gchar* perm;  gboolean set;  inf_acl_mask_clear(mask);  inf_acl_mask_clear(perms);  enum_class = G_ENUM_CLASS(g_type_class_ref(INF_TYPE_ACL_SETTING));  g_variant_iter_init(&iter, variant);  while(g_variant_iter_next(&iter, "{&sb}", &perm, &set))  {    val = g_enum_get_value_by_nick(enum_class, perm);    if(val == NULL)    {      g_set_error(        error,        G_DBUS_ERROR,        G_DBUS_ERROR_INVALID_ARGS,        "No such permission: /"%s/"",        perm      );      g_type_class_unref(enum_class);      return FALSE;    }    inf_acl_mask_or1(mask, val->value);    if(set == TRUE)      inf_acl_mask_or1(perms, val->value);  }  g_type_class_unref(enum_class);  return TRUE;}