gint
gnc_enum_from_nick(GType type,
const gchar *name,
gint default_value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
gchar *alt_name, *ptr;
if (name == NULL)
return default_value;
/* Lookup the enum class in the glib type system */
enum_class = g_type_class_ref (type);
if (!enum_class)
{
/* g_type_class_ref has already printed a warning. */
return default_value;
}
/* Lookup the specified enum in the class */
enum_value = g_enum_get_value_by_nick(enum_class, name);
if (enum_value)
return enum_value->value;
/* Flip '-' and '_' and try again */
alt_name = g_strdup(name);
if ((ptr = strchr(alt_name, '-')) != NULL)
{
do
{
*ptr++ = '_';
}
while ((ptr = strchr(ptr, '-')) != NULL);
}
else if ((ptr = strchr(alt_name, '_')) != NULL)
{
do
{
*ptr++ = '-';
}
while ((ptr = strchr(ptr, '_')) != NULL);
}
else
{
g_free(alt_name);
return default_value;
}
/* Lookup the specified enum in the class */
enum_value = g_enum_get_value_by_nick(enum_class, alt_name);
g_free(alt_name);
if (enum_value)
return enum_value->value;
return default_value;
}
static void
gimp_cursor_view_set_aux_info (GimpDocked *docked,
GList *aux_info)
{
GimpCursorView *view = GIMP_CURSOR_VIEW (docked);
GList *list;
parent_docked_iface->set_aux_info (docked, aux_info);
for (list = aux_info; list; list = g_list_next (list))
{
GimpSessionInfoAux *aux = list->data;
GtkWidget *frame = NULL;
if (! strcmp (aux->name, AUX_INFO_FRAME_1_MODE))
frame = view->color_frame_1;
else if (! strcmp (aux->name, AUX_INFO_FRAME_2_MODE))
frame = view->color_frame_2;
if (frame)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
enum_class = g_type_class_peek (GIMP_TYPE_COLOR_FRAME_MODE);
enum_value = g_enum_get_value_by_nick (enum_class, aux->value);
if (enum_value)
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (frame),
enum_value->value);
}
}
}
static void _xfdashboard_gvalue_transform_string_enum(const GValue *inSourceValue, GValue *ioDestValue)
{
GEnumClass *enumClass;
GEnumValue *enumValue;
const gchar *value;
/* Reference enum class to keep it alive for transformation */
enumClass=g_type_class_ref(G_VALUE_TYPE(ioDestValue));
/* Get value to convert */
value=(const gchar*)inSourceValue->data[0].v_pointer;
/* Get enum value either by name or by nickname (whatever matches first) */
enumValue=g_enum_get_value_by_name(enumClass, value);
if(!enumValue) enumValue=g_enum_get_value_by_nick(enumClass, value);
/* Set value if enum could be found otherwise set 0 */
if(enumValue) ioDestValue->data[0].v_int=enumValue->value;
else
{
ioDestValue->data[0].v_int=0;
g_debug("Cannot get value for unknown enum '%s' for type %s",
value, g_type_name(G_VALUE_TYPE(ioDestValue)));
}
/* Release allocated resources */
g_type_class_unref(enumClass);
}
static void
preferences_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);
}
}
/**
* 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
*/
AtkStateType
atk_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;
}
/**
* bluetooth_chooser_get_selected_device_info:
* @self: A #BluetoothChooser widget.
* @field: The identifier for the field to get data for.
* @value: An empty #GValue to set.
*
* Returns whether the @value has been set.
*
* Return value: %TRUE if the @value has been set.
**/
gboolean
bluetooth_chooser_get_selected_device_info (BluetoothChooser *self,
const char *field,
GValue *value)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GEnumClass *eclass;
GEnumValue *ev;
GtkTreeIter iter;
g_return_val_if_fail (field != NULL, FALSE);
if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter) == FALSE)
return FALSE;
eclass = g_type_class_ref (BLUETOOTH_TYPE_COLUMN);
ev = g_enum_get_value_by_nick (eclass, field);
if (ev == NULL) {
g_warning ("Unknown field '%s'", field);
g_type_class_unref (eclass);
return FALSE;
}
gtk_tree_model_get_value (priv->filter, &iter, ev->value, value);
g_type_class_unref (eclass);
return TRUE;
}
static void
main_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 void
show_settings_cb(GSimpleAction* action,
GVariant* par,
gpointer udata)
{
GtWin* self = GT_WIN(udata);
GtWinPrivate* priv = gt_win_get_instance_private(self);
if (!priv->settings_dlg)
{
priv->settings_dlg = gt_settings_dlg_new(self);
g_object_add_weak_pointer(G_OBJECT(priv->settings_dlg), (gpointer *) &priv->settings_dlg);
}
if (par)
{
GEnumClass* eclass = g_type_class_ref(GT_TYPE_SETTINGS_DLG_VIEW);
GEnumValue* eval = g_enum_get_value_by_nick(eclass, g_variant_get_string(par, NULL));
gt_settings_dlg_set_view(priv->settings_dlg, eval->value);
g_simple_action_set_state(action, par);
g_type_class_unref(eclass);
}
gtk_window_present(GTK_WINDOW(priv->settings_dlg));
}
PhotosZoomEvent
photos_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;
}
static gboolean
enum_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
char *str;
str = _gtk_css_parser_try_ident (parser, TRUE);
if (str == NULL)
{
_gtk_css_parser_error (parser, "Expected an identifier");
return FALSE;
}
enum_class = g_type_class_ref (G_VALUE_TYPE (value));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
g_value_set_enum (value, enum_value->value);
else
_gtk_css_parser_error (parser,
"Unknown value '%s' for enum type '%s'",
str, g_type_name (G_VALUE_TYPE (value)));
g_type_class_unref (enum_class);
g_free (str);
return enum_value != NULL;
}
static gboolean
enum_from_string (GType type,
const gchar *string,
gint *enum_value)
{
GEnumClass *eclass;
GEnumValue *ev;
gchar *endptr;
gint value;
gboolean retval = TRUE;
g_return_val_if_fail (G_TYPE_IS_ENUM (type), 0);
g_return_val_if_fail (string != NULL, 0);
value = strtoul (string, &endptr, 0);
if (endptr != string) /* parsed a number */
*enum_value = value;
else
{
eclass = g_type_class_ref (type);
ev = g_enum_get_value_by_name (eclass, string);
if (!ev)
ev = g_enum_get_value_by_nick (eclass, string);
if (ev)
*enum_value = ev->value;
else
retval = FALSE;
g_type_class_unref (eclass);
}
return retval;
}
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);
}
int
go_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;
}
void
apply_fx (GstElement * element, const gchar * fx)
{
GEnumClass *p_class;
/* from fxtest ;) */
/* heeeellppppp!! */
p_class =
G_PARAM_SPEC_ENUM (g_object_class_find_property (G_OBJECT_GET_CLASS
(G_OBJECT (data)), "effect")
)->enum_class;
g_print ("setting: %s - %s\n", fx, g_enum_get_value_by_nick (p_class,
fx)->value_name);
g_object_set (G_OBJECT (element), "effect", g_enum_get_value_by_nick (p_class,
fx)->value, NULL);
}
static void
parse_params (const gchar *str,
gint *width,
gint *ellipsize_at,
PangoEllipsizeMode *ellipsize,
PangoWrapMode *wrap)
{
gchar **strings;
gchar **str2;
gint i;
GEnumClass *eclass;
GEnumValue *ev;
strings = g_strsplit (str, ",", -1);
for (i = 0; strings[i]; i++)
{
str2 = g_strsplit (strings[i], "=", -1);
if (strcmp (str2[0], "width") == 0)
*width = (gint) g_ascii_strtoll (str2[1], NULL, 10);
else if (strcmp (str2[0], "ellipsize-at") == 0)
*ellipsize_at = (gint) g_ascii_strtoll (str2[1], NULL, 10);
else if (strcmp (str2[0], "ellipsize") == 0)
{
eclass = g_type_class_ref (PANGO_TYPE_ELLIPSIZE_MODE);
ev = g_enum_get_value_by_name (eclass, str2[1]);
if (!ev)
ev = g_enum_get_value_by_nick (eclass, str2[1]);
if (ev)
*ellipsize = ev->value;
g_type_class_unref (eclass);
}
else if (strcmp (str2[0], "wrap") == 0)
{
eclass = g_type_class_ref (PANGO_TYPE_WRAP_MODE);
ev = g_enum_get_value_by_name (eclass, str2[1]);
if (!ev)
ev = g_enum_get_value_by_nick (eclass, str2[1]);
if (ev)
*wrap = ev->value;
g_type_class_unref (eclass);
}
g_strfreev (str2);
}
g_strfreev (strings);
}
/**
* 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
*/
gint
pyg_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 gboolean
apply_fx (GtkWidget * widget, gpointer data)
{
gchar *fx;
GEnumClass *p_class;
/* heeeellppppp!! */
p_class =
G_PARAM_SPEC_ENUM (g_object_class_find_property (G_OBJECT_GET_CLASS
(G_OBJECT (data)), "effect")
)->enum_class;
fx = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (widget));
g_print ("setting: %s - %s\n", fx, g_enum_get_value_by_nick (p_class,
fx)->value_name);
g_object_set (G_OBJECT (data), "effect", g_enum_get_value_by_nick (p_class,
fx)->value, NULL);
return FALSE;
}
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;
}
/* GESExtractable interface overrides */
static GParameter *
extractable_get_parameters_from_id (const gchar * id, guint * n_params)
{
GEnumClass *enum_class =
g_type_class_peek (GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE);
GParameter *params = g_new0 (GParameter, 1);
GEnumValue *value = g_enum_get_value_by_nick (enum_class, id);
params[0].name = "vtype";
g_value_init (¶ms[0].value, GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE);
g_value_set_enum (¶ms[0].value, value->value);
*n_params = 1;
return params;
}
void
modem_error_fix (GError **error)
{
if (*error == NULL ||
(*error)->domain != DBUS_GERROR ||
(*error)->code != DBUS_GERROR_REMOTE_EXCEPTION)
return;
ModemErrorMapping const *map;
GEnumClass *gec;
GEnumValue *ev;
GError *fixed;
char const *fqe = (*error)->message + strlen ((*error)->message) + 1;
map = modem_registered_errors_reader_lock ();
for (; map; map = map->next)
if (strncmp (fqe, map->prefix, map->prefixlen) == 0 &&
fqe[map->prefixlen] == '.' &&
strchr (fqe + map->prefixlen + 1, '.') == 0)
break;
modem_registered_errors_reader_unlock ();
if (!map)
{
DEBUG ("no match for %s", fqe);
return;
}
gec = g_type_class_peek (map->type);
ev = g_enum_get_value_by_nick (gec, fqe + map->prefixlen + 1);
if (ev == NULL)
{
DEBUG ("no code point for %s", fqe);
return;
}
fixed = g_error_new_literal (map->domain, ev->value, (*error)->message);
g_clear_error (error);
*error = fixed;
}
static gboolean
int_enum_get_mapping (GValue *value, GVariant *variant, GEnumClass *enum_class)
{
GEnumValue *enum_value;
const gchar *nick;
g_return_val_if_fail (G_IS_ENUM_CLASS (enum_class), FALSE);
nick = g_variant_get_string (variant, NULL);
enum_value = g_enum_get_value_by_nick (enum_class, nick);
if (enum_value == NULL)
return FALSE;
g_value_set_int (value, enum_value->value);
return TRUE;
}
static int
parse_enum(GType type,
const char *string)
{
GEnumClass *enum_klass;
const GEnumValue *enum_value;
int value = 0;
enum_klass = (GEnumClass*)g_type_class_ref(type);
enum_value = g_enum_get_value_by_nick(enum_klass, string);
if (enum_value)
value = enum_value->value;
else
g_warning("Unknown enum '%s'\n", string);
g_type_class_unref(enum_klass);
return value;
}
G_GNUC_INTERNAL int
gvir_config_genum_get_value (GType enum_type, const char *nick,
gint default_value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
g_return_val_if_fail(G_TYPE_IS_ENUM(enum_type), default_value);
g_return_val_if_fail(nick != NULL, default_value);
enum_class = g_type_class_ref(enum_type);
enum_value = g_enum_get_value_by_nick(enum_class, nick);
g_type_class_unref(enum_class);
if (enum_value != NULL)
return enum_value->value;
g_return_val_if_reached(default_value);
}
/**
* 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.
**/
AtkRelationType
atk_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 gboolean
infinoted_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;
}
/**
* ges_test_clip_new_for_nick:
* @nick: the nickname for which to create the #GESTestClip
*
* Creates a new #GESTestClip for the provided @nick.
*
* Returns: The newly created #GESTestClip, or NULL if there was an
* error.
*/
GESTestClip *
ges_test_clip_new_for_nick (gchar * nick)
{
GEnumValue *value;
GEnumClass *klass;
GESTestClip *ret = NULL;
klass = G_ENUM_CLASS (g_type_class_ref (GES_VIDEO_TEST_PATTERN_TYPE));
if (!klass)
return NULL;
value = g_enum_get_value_by_nick (klass, nick);
if (value) {
ret = ges_test_clip_new ();
ges_test_clip_set_vpattern (ret, value->value);
}
g_type_class_unref (klass);
return ret;
}
gboolean
qmicli_read_radio_interface_from_string (const gchar *str,
QmiNasRadioInterface *out)
{
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
type = qmi_nas_radio_interface_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_ref (type));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
*out = (QmiNasRadioInterface)enum_value->value;
else
g_printerr ("error: invalid radio interface value given: '%s'\n", str);
g_type_class_unref (enum_class);
return !!enum_value;
}
gboolean
qmicli_read_link_layer_protocol_from_string (const gchar *str,
QmiWdaLinkLayerProtocol *out)
{
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
type = qmi_wda_link_layer_protocol_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_ref (type));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
*out = (QmiWdaLinkLayerProtocol)enum_value->value;
else
g_printerr ("error: invalid link layer protocol value given: '%s'\n", str);
g_type_class_unref (enum_class);
return !!enum_value;
}
gboolean
qmicli_read_operating_mode_from_string (const gchar *str,
QmiDmsOperatingMode *out)
{
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
type = qmi_dms_operating_mode_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_ref (type));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
*out = (QmiDmsOperatingMode)enum_value->value;
else
g_printerr ("error: invalid operating mode value given: '%s'\n", str);
g_type_class_unref (enum_class);
return !!enum_value;
}
gboolean
qmicli_read_facility_from_string (const gchar *str,
QmiDmsUimFacility *out)
{
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
type = qmi_dms_uim_facility_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_ref (type));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
*out = (QmiDmsUimFacility)enum_value->value;
else
g_printerr ("error: invalid facility value given: '%s'\n", str);
g_type_class_unref (enum_class);
return !!enum_value;
}
