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;
}
gint
asCEnum(USER_OBJECT_ s_enum, GType etype)
{
GEnumClass *eclass = g_type_class_ref(etype);
GEnumValue *evalue = NULL;
gint eval = 0;
if (IS_INTEGER(s_enum) || IS_NUMERIC(s_enum)) {
evalue = g_enum_get_value(eclass, asCInteger(s_enum));
} else if (IS_CHARACTER(s_enum)) {
const gchar* ename = asCString(s_enum);
evalue = g_enum_get_value_by_name(eclass, ename);
if (!evalue)
evalue = g_enum_get_value_by_nick(eclass, ename);
if (!evalue)
evalue = g_enum_get_value(eclass, atoi(ename));
}
if (!evalue) {
PROBLEM "Could not parse enum value %s", asCString(s_enum)
ERROR;
} else eval = evalue->value;
return(eval);
}
static GstCaps *sbc_enc_generate_srcpad_caps(GstSbcEnc *enc)
{
GstCaps *src_caps;
GstStructure *structure;
GEnumValue *enum_value;
GEnumClass *enum_class;
GValue *value;
src_caps = gst_caps_copy(gst_pad_get_pad_template_caps(enc->srcpad));
structure = gst_caps_get_structure(src_caps, 0);
value = g_new0(GValue, 1);
if (enc->rate != 0)
gst_sbc_util_set_structure_int_param(structure, "rate",
enc->rate, value);
if (enc->channels != 0)
gst_sbc_util_set_structure_int_param(structure, "channels",
enc->channels, value);
if (enc->subbands != 0)
gst_sbc_util_set_structure_int_param(structure, "subbands",
enc->subbands, value);
if (enc->blocks != 0)
gst_sbc_util_set_structure_int_param(structure, "blocks",
enc->blocks, value);
if (enc->bitpool != SBC_ENC_BITPOOL_AUTO)
gst_sbc_util_set_structure_int_param(structure, "bitpool",
enc->bitpool, value);
if (enc->mode != SBC_ENC_DEFAULT_MODE) {
enum_class = g_type_class_ref(GST_TYPE_SBC_MODE);
enum_value = g_enum_get_value(enum_class, enc->mode);
gst_sbc_util_set_structure_string_param(structure, "mode",
enum_value->value_nick, value);
g_type_class_unref(enum_class);
}
if (enc->allocation != SBC_AM_AUTO) {
enum_class = g_type_class_ref(GST_TYPE_SBC_ALLOCATION);
enum_value = g_enum_get_value(enum_class, enc->allocation);
gst_sbc_util_set_structure_string_param(structure, "allocation",
enum_value->value_nick, value);
g_type_class_unref(enum_class);
}
g_free(value);
return src_caps;
}
/**
* 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;
}
/**
* moto_enum_store_new_with_values_valist:
* @enum_type: the #GType of an enum.
* @n_values: the number of enum values to include
* @args: a va_list of enum values (exactly @n_values)
*
* See moto_enum_store_new_with_values().
*
* Return value: a new #MotoEnumStore.
*
* Since: MOTO 2.4
**/
GtkListStore *
moto_enum_store_new_with_values_valist(GType enum_type,
gint n_values,
va_list args)
{
GtkListStore *store;
GEnumValue *value;
gint i;
g_return_val_if_fail(G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail(n_values > 1, NULL);
store = g_object_new(MOTO_TYPE_ENUM_STORE,
"enum-type", enum_type,
NULL);
for(i = 0; i < n_values; i++)
{
value = g_enum_get_value(MOTO_ENUM_STORE (store)->enum_class,
va_arg (args, gint));
if(value)
moto_enum_store_add_value(store, value);
}
return store;
}
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;
}
/**
* xfdashboard_get_enum_value_name:
* @inEnumClass: The #GType of enum class
* @inValue: The numeric value of enumeration at @inEnumClass
*
* Returns textual representation for numeric value @inValue of
* enumeration class @inEnumClass.
*
* Return value: A string containig the textual representation or
* %NULL if @inValue is not a value of enumeration
* @inEnumClass. Use g_free() to free returned string.
*/
gchar* xfdashboard_get_enum_value_name(GType inEnumClass, gint inValue)
{
GEnumClass *enumClass;
GEnumValue *enumValue;
gchar *valueName;
enumClass=NULL;
enumValue=NULL;
valueName=NULL;
/* Reference enum class to keep it alive for transformation */
enumClass=g_type_class_ref(inEnumClass);
/* Get enum value */
if(enumClass) enumValue=g_enum_get_value(enumClass, inValue);
/* Get a copy of value's name if it could be found */
if(enumValue)
{
valueName=g_strdup(enumValue->value_name);
}
/* Release allocated resources */
if(enumClass) g_type_class_unref(enumClass);
/* Return name */
return(valueName);
}
/**
* 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;
}
static gchar *
format_channel_mask (GstDiscovererAudioInfo * ainfo)
{
GString *s = g_string_sized_new (32);
GstAudioChannelPosition position[64];
guint channels = gst_discoverer_audio_info_get_channels (ainfo);
GEnumClass *enum_class = g_type_class_ref (GST_TYPE_AUDIO_CHANNEL_POSITION);
guint i;
guint64 channel_mask;
if (channels == 0)
goto done;
channel_mask = gst_discoverer_audio_info_get_channel_mask (ainfo);
if (channel_mask != 0) {
gst_audio_channel_positions_from_mask (channels, channel_mask, position);
for (i = 0; i < channels; i++) {
GEnumValue *value = g_enum_get_value (enum_class, position[i]);
my_g_string_append_printf (s, 0, "%s%s", value->value_nick,
i + 1 == channels ? "" : ", ");
}
} else {
g_string_append (s, "unknown layout");
}
g_type_class_unref (enum_class);
done:
return g_string_free (s, FALSE);
}
static gboolean
build_enum_subset_values_from_mask (GstVaapiEnumSubset * subset, guint32 mask)
{
GEnumClass *enum_class;
const GEnumValue *value;
guint i, n;
enum_class = g_type_class_ref (subset->parent_type);
if (!enum_class)
return FALSE;
for (i = 0, n = 0; i < 32 && n < subset->num_values; i++) {
if (!(mask & (1U << i)))
continue;
value = g_enum_get_value (enum_class, i);
if (!value)
continue;
subset->values[n++] = *value;
}
g_type_class_unref (enum_class);
if (n != subset->num_values - 1)
goto error_invalid_num_values;
return TRUE;
/* ERRORS */
error_invalid_num_values:
{
g_error ("invalid number of static values for `%s'", subset->type_name);
return FALSE;
}
}
GParamSpec*
g_param_spec_enum (const gchar *name,
const gchar *nick,
const gchar *blurb,
GType enum_type,
gint default_value,
GParamFlags flags)
{
GParamSpecEnum *espec;
GEnumClass *enum_class;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref (enum_type);
g_return_val_if_fail (g_enum_get_value (enum_class, default_value) != NULL, NULL);
espec = g_param_spec_internal (G_TYPE_PARAM_ENUM,
name,
nick,
blurb,
flags);
espec->enum_class = enum_class;
espec->default_value = default_value;
G_PARAM_SPEC (espec)->value_type = enum_type;
return G_PARAM_SPEC (espec);
}
/**
* 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;
}
static void
main_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);
}
static void
gimp_enum_store_insert_value_after (GimpEnumStore *store,
gint after,
gint insert_value)
{
GtkTreeIter iter;
g_return_if_fail (GIMP_IS_ENUM_STORE (store));
if (gimp_int_store_lookup_by_value (GTK_TREE_MODEL (store),
after, &iter))
{
GEnumValue *enum_value;
enum_value = g_enum_get_value (store->enum_class, insert_value);
if (enum_value)
{
GtkTreeIter value_iter;
const gchar *desc;
gtk_list_store_insert_after (GTK_LIST_STORE (store),
&value_iter, &iter);
desc = gimp_enum_value_get_desc (store->enum_class, enum_value);
gtk_list_store_set (GTK_LIST_STORE (store), &value_iter,
GIMP_INT_STORE_VALUE, enum_value->value,
GIMP_INT_STORE_LABEL, desc,
-1);
}
}
}
USER_OBJECT_
asREnum(int value, GType etype)
{
USER_OBJECT_ ans, names;
GEnumValue *evalue;
PROTECT(ans = NEW_INTEGER(1));
INTEGER_DATA(ans)[0] = value;
if (!(evalue = g_enum_get_value(g_type_class_ref(etype), value))) {
PROBLEM "Unknown enum value %d", value
ERROR;
}
PROTECT(names = NEW_CHARACTER(1));
SET_STRING_ELT(names, 0, COPY_TO_USER_STRING(evalue->value_name));
SET_NAMES(ans, names);
PROTECT(names = NEW_CHARACTER(2));
SET_STRING_ELT(names, 0, COPY_TO_USER_STRING(g_type_name(etype)));
SET_STRING_ELT(names, 1, COPY_TO_USER_STRING("enum"));
SET_CLASS(ans, names);
UNPROTECT(3);
return(ans);
}
static void
thunar_column_model_save_column_order (ThunarColumnModel *column_model)
{
GEnumClass *klass;
GEnumValue *value;
GString *column_order;
gint n;
/* allocate a string for the column order */
column_order = g_string_sized_new (256);
/* transform the internal visible column list */
klass = g_type_class_ref (THUNAR_TYPE_COLUMN);
for (n = 0; n < THUNAR_N_VISIBLE_COLUMNS; ++n)
{
/* append a comma if not empty */
if (*column_order->str != '\0')
g_string_append_c (column_order, ',');
/* append the enum value name */
value = g_enum_get_value (klass, column_model->order[n]);
g_string_append (column_order, value->value_name);
}
g_type_class_unref (klass);
/* save the list of visible columns */
g_signal_handlers_block_by_func (G_OBJECT (column_model->preferences), thunar_column_model_notify_column_order, column_model);
g_object_set (G_OBJECT (column_model->preferences), "last-details-view-column-order", column_order->str, NULL);
g_signal_handlers_unblock_by_func (G_OBJECT (column_model->preferences), thunar_column_model_notify_column_order, column_model);
/* release the string */
g_string_free (column_order, TRUE);
}
static GsApp *
snap_to_app (GsPlugin *plugin, SnapdSnap *snap)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GStrv common_ids;
g_autofree gchar *appstream_id = NULL;
g_autofree gchar *unique_id = NULL;
g_autoptr(GsApp) app = NULL;
SnapdConfinement confinement;
/* Get the AppStream ID from the snap, or generate a fallback one */
common_ids = snapd_snap_get_common_ids (snap);
if (g_strv_length (common_ids) == 1)
appstream_id = g_strdup (common_ids[0]);
else
appstream_id = g_strdup_printf ("io.snapcraft.%s-%s", snapd_snap_get_name (snap), snapd_snap_get_id (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
unique_id = g_strdup_printf ("system/snap/*/desktop/%s/*", appstream_id);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
unique_id = g_strdup_printf ("system/snap/*/runtime/%s/*", appstream_id);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
unique_id = g_strdup_printf ("system/snap/*/*/%s/*", appstream_id);
break;
}
app = gs_plugin_cache_lookup (plugin, unique_id);
if (app == NULL) {
app = gs_app_new (NULL);
gs_app_set_from_unique_id (app, unique_id);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_metadata (app, "snap::name", snapd_snap_get_name (snap));
gs_plugin_cache_add (plugin, unique_id, app);
}
gs_app_set_management_plugin (app, "snap");
if (gs_app_get_kind (app) != AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
if (gs_plugin_check_distro_id (plugin, "ubuntu"))
gs_app_add_quirk (app, GS_APP_QUIRK_PROVENANCE);
confinement = snapd_snap_get_confinement (snap);
if (confinement != SNAPD_CONFINEMENT_UNKNOWN) {
GEnumClass *enum_class = g_type_class_ref (SNAPD_TYPE_CONFINEMENT);
gs_app_set_metadata (app, "snap::confinement", g_enum_get_value (enum_class, confinement)->value_nick);
g_type_class_unref (enum_class);
}
if (priv->system_confinement == SNAPD_SYSTEM_CONFINEMENT_STRICT && confinement == SNAPD_CONFINEMENT_STRICT)
gs_app_add_kudo (app, GS_APP_KUDO_SANDBOXED);
return g_steal_pointer (&app);
}
void
go_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);
}
static const char*
enum_to_string (GType enum_type,
int value)
{
GEnumValue *v;
v = g_enum_get_value (g_type_class_peek (enum_type), value);
return v->value_nick;
}
/**
* fo_libfo_context_set_font_embed:
* @libfo_context: #FoLibfoContext.
* @font_embed: New 'font-embed' value for @libfo_context.
*
* Set the 'font-embed' property of @libfo_context.
**/
void
fo_libfo_context_set_font_embed (FoLibfoContext *libfo_context,
FoEnumFontEmbed font_embed)
{
g_return_if_fail (FO_IS_LIBFO_CONTEXT (libfo_context));
g_return_if_fail (g_enum_get_value (g_type_class_peek (FO_TYPE_ENUM_FONT_EMBED),
font_embed) != NULL);
libfo_context->font_embed = font_embed;
}
const gchar *dasom_message_get_name_by_type (DasomMessageType type)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
GEnumClass *enum_class = (GEnumClass *) g_type_class_ref (DASOM_TYPE_MESSAGE_TYPE);
GEnumValue *enum_value = g_enum_get_value (enum_class, type);
g_type_class_unref (enum_class);
return enum_value ? enum_value->value_name : NULL;
}
static void
update_stream_info (GthMediaViewerPage *self)
{
GList *streaminfo;
GstPad *videopad;
streaminfo = NULL;
videopad = NULL;
g_object_get (self->priv->playbin, "stream-info", &streaminfo, NULL);
streaminfo = g_list_copy (streaminfo);
g_list_foreach (streaminfo, (GFunc) g_object_ref, NULL);
for (/* void */ ; streaminfo; streaminfo = streaminfo->next) {
GObject *info;
int type;
GParamSpec *pspec;
GEnumValue *val;
info = streaminfo->data;
if (info == NULL)
continue;
type = -1;
g_object_get (info, "type", &type, NULL);
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (info), "type");
val = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, type);
if (strcmp (val->value_nick, "audio") == 0) {
self->priv->has_audio = TRUE;
}
else if (strcmp (val->value_nick, "video") == 0) {
self->priv->has_video = TRUE;
if (videopad == NULL)
g_object_get (info, "object", &videopad, NULL);
}
}
if (videopad != NULL) {
GstCaps *caps;
if ((caps = gst_pad_get_negotiated_caps (videopad)) != NULL) {
GstStructure *structure;
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_fraction (structure, "framerate", &self->priv->video_fps_n, &self->priv->video_fps_d);
gst_caps_unref (caps);
}
}
g_list_foreach (streaminfo, (GFunc) g_object_unref, NULL);
g_list_free (streaminfo);
}
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;
}
static void
_stream_state_changed (FsStreamTransmitter *st, guint component,
FsStreamState state, gpointer user_data)
{
FsTransmitter *trans = FS_TRANSMITTER (user_data);
GEnumClass *enumclass = NULL;
GEnumValue *enumvalue = NULL;
gchar *prop = NULL;
FsStreamState oldstate = 0;
enumclass = g_type_class_ref (FS_TYPE_STREAM_STATE);
enumvalue = g_enum_get_value (enumclass, state);
GST_DEBUG ("%p: Stream state for component %u is now %s (%u)", st,
component, enumvalue->value_nick, state);
ts_fail_if (state == FS_STREAM_STATE_FAILED,
"Failed to establish a connection");
if (component == 1)
prop = "last-state-1";
else if (component == 2)
prop = "last-state-2";
else
ts_fail ("Invalid component %u, component");
oldstate = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (st), prop));
ts_fail_if (state < FS_STREAM_STATE_CONNECTED && state < oldstate,
"State went in wrong direction %d -> %d for component %u",
oldstate, state, component);
g_object_set_data (G_OBJECT (st), prop, GINT_TO_POINTER (state));
if (state < FS_STREAM_STATE_READY)
return;
if (component == 1)
prop = "src_setup_1";
else if (component == 2)
prop = "src_setup_2";
if (g_object_get_data (G_OBJECT (trans), prop) == NULL)
{
GstElement *pipeline = GST_ELEMENT (
g_object_get_data (G_OBJECT (trans), "pipeline"));
GST_DEBUG ("%p: Setting up fakesrc for component %u", st, component);
setup_fakesrc (trans, pipeline, component);
g_object_set_data (G_OBJECT (trans), prop, "");
}
else
GST_DEBUG ("FAKESRC ALREADY SETUP for component %u", component);
}
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 GTokenType
gimp_config_deserialize_enum (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
enum_class = g_type_class_peek (G_VALUE_TYPE (value));
switch (g_scanner_peek_next_token (scanner))
{
case G_TOKEN_IDENTIFIER:
g_scanner_get_next_token (scanner);
enum_value = g_enum_get_value_by_nick (enum_class,
scanner->value.v_identifier);
if (!enum_value)
enum_value = g_enum_get_value_by_name (enum_class,
scanner->value.v_identifier);
if (!enum_value)
{
g_scanner_error (scanner,
_("invalid value '%s' for token %s"),
scanner->value.v_identifier, prop_spec->name);
return G_TOKEN_NONE;
}
break;
case G_TOKEN_INT:
g_scanner_get_next_token (scanner);
enum_value = g_enum_get_value (enum_class,
(gint) scanner->value.v_int64);
if (!enum_value)
{
g_scanner_error (scanner,
_("invalid value '%ld' for token %s"),
(glong) scanner->value.v_int64, prop_spec->name);
return G_TOKEN_NONE;
}
break;
default:
return G_TOKEN_IDENTIFIER;
}
g_value_set_enum (value, enum_value->value);
return G_TOKEN_RIGHT_PAREN;
}
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 gboolean
param_enum_validate (GParamSpec *pspec,
GValue *value)
{
GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec);
glong oval = value->data[0].v_long;
if (!espec->enum_class ||
!g_enum_get_value (espec->enum_class, value->data[0].v_long))
value->data[0].v_long = espec->default_value;
return value->data[0].v_long != oval;
}
static inline gboolean
gst_tag_image_type_is_valid (GstTagImageType type)
{
GEnumClass *klass;
gboolean res;
klass = g_type_class_ref (gst_tag_image_type_get_type ());
res = (g_enum_get_value (klass, type) != NULL);
g_type_class_unref (klass);
return res;
}
