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
*/
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;
}
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);
}
}
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 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
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);
}
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;
}
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;
}
/**
* 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;
}
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
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);
}
/**
* 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 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 void
output_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 void
gst_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 void
gst_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 void
print_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 void
enum_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
#endif
void
gst_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 void
enum_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.
**/
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;
}
