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; }