/** * fo_libfo_context_set_format: * @libfo_context: #FoLibfoContext. * @format: New 'format' value for @libfo_context. * * Set the 'format' property of @libfo_context. * * If more that one flag value is set in @format, only the first * (lowest) set value will be used. **/ void fo_libfo_context_set_format (FoLibfoContext *libfo_context, FoFlagsFormat format) { g_return_if_fail (FO_IS_LIBFO_CONTEXT (libfo_context)); g_return_if_fail (g_flags_get_first_value (g_type_class_peek (FO_TYPE_FLAGS_FORMAT), format) != NULL); libfo_context->format = g_flags_get_first_value (g_type_class_peek (FO_TYPE_FLAGS_FORMAT), format)->value; }
static gboolean on_key_press_event (GtkWidget *widget, GdkEvent *event, GtkWidget *dialog) { const gchar *keystr; GString *combination; GFlagsClass *flags_class; /* do not free */ guint mod; guint i; combination = g_string_new (""); mod = event->key.state & NIMF_MODIFIER_MASK; flags_class = (GFlagsClass *) g_type_class_ref (NIMF_TYPE_MODIFIER_TYPE); /* does not use virtual modifiers */ for (i = 0; i <= 12; i++) { GFlagsValue *flags_value = g_flags_get_first_value (flags_class, mod & (1 << i)); if (flags_value) g_string_append_printf (combination, "%s ", flags_value->value_nick); } g_type_class_unref (flags_class); keystr = nimf_keyval_to_keysym_name (event->key.keyval); if (keystr == NULL) { gchar *text; g_string_free (combination, TRUE); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, FALSE); text = g_strdup_printf (_("Please report a bug. (keyval: %d)"), event->key.keyval); gtk_entry_set_text (GTK_ENTRY (widget), text); g_free (text); g_return_val_if_fail (keystr, TRUE); } g_string_append_printf (combination, "%s", keystr); gtk_entry_set_text (GTK_ENTRY (widget), combination->str); gtk_editable_set_position (GTK_EDITABLE (widget), -1); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, TRUE); g_string_free (combination, TRUE); return TRUE; }
/** * gimp_flags_get_first_value: * @flags_type: the #GType of registered flags * @value: an integer value * @value_name: return location for the value's name (or %NULL) * @value_nick: return location for the value's nick (or %NULL) * @value_desc: return location for the value's translated description (or %NULL) * @value_help: return location for the value's translated help (or %NULL) * * Checks if @value is valid for the flags registered as @flags_type. * If the value exists in that flags, its name, nick and its * translated description and help are returned (if @value_name, * @value_nick, @value_desc and @value_help are not %NULL). * * Return value: %TRUE if @value is valid for the @flags_type, * %FALSE otherwise * * Since: GIMP 2.2 **/ gboolean gimp_flags_get_first_value (GType flags_type, guint value, const gchar **value_name, const gchar **value_nick, const gchar **value_desc, const gchar **value_help) { GFlagsClass *flags_class; GFlagsValue *flags_value; g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), FALSE); flags_class = g_type_class_peek (flags_type); flags_value = g_flags_get_first_value (flags_class, value); if (flags_value) { if (value_name) *value_name = flags_value->value_name; if (value_nick) *value_nick = flags_value->value_nick; if (value_desc || value_help) { GimpFlagsDesc *flags_desc; flags_desc = gimp_flags_get_first_desc (flags_class, value); if (value_desc) *value_desc = ((flags_desc && flags_desc->value_desc) ? dgettext (gimp_type_get_translation_domain (flags_type), flags_desc->value_desc) : NULL); if (value_help) *value_help = ((flags_desc && flags_desc->value_desc) ? dgettext (gimp_type_get_translation_domain (flags_type), flags_desc->value_help) : NULL); } return TRUE; } return FALSE; }
static void print_event_masks (const GstEventMask * masks, gint pfx) { GType event_type; GEnumClass *klass; GType event_flags; GFlagsClass *flags_class = NULL; event_type = gst_event_type_get_type (); klass = (GEnumClass *) g_type_class_ref (event_type); while (masks && masks->type) { GEnumValue *value; gint flags = 0, index = 0; switch (masks->type) { case GST_EVENT_SEEK: flags = masks->flags; event_flags = gst_seek_type_get_type (); flags_class = (GFlagsClass *) g_type_class_ref (event_flags); break; default: break; } value = g_enum_get_value (klass, masks->type); PUT_STRING (pfx, "<event type=\"%s\">", value->value_nick); while (flags) { GFlagsValue *value; if (flags & 1) { value = g_flags_get_first_value (flags_class, 1 << index); if (value) PUT_ESCAPED (pfx + 1, "flag", value->value_nick); else PUT_ESCAPED (pfx + 1, "flag", "?"); } flags >>= 1; index++; } PUT_END_TAG (pfx, "event"); masks++; } }
static void print_event_masks (const GstEventMask * masks) { GType event_type; GEnumClass *klass; GType event_flags; GFlagsClass *flags_class = NULL; event_type = gst_event_type_get_type (); klass = (GEnumClass *) g_type_class_ref (event_type); while (masks && masks->type) { GEnumValue *value; gint flags = 0, index = 0; switch (masks->type) { case GST_EVENT_SEEK: flags = masks->flags; event_flags = gst_seek_type_get_type (); flags_class = (GFlagsClass *) g_type_class_ref (event_flags); break; default: break; } value = g_enum_get_value (klass, masks->type); g_print ("\t\t%s ", value->value_nick); while (flags) { GFlagsValue *value; if (flags & 1) { value = g_flags_get_first_value (flags_class, 1 << index); if (value) g_print ("| %s ", value->value_nick); else g_print ("| ? "); } flags >>= 1; index++; } g_print ("\n"); masks++; } }
GVariant * g_settings_set_mapping (const GValue *value, const GVariantType *expected_type, gpointer user_data) { gchar *type_string; if (G_VALUE_HOLDS_BOOLEAN (value)) { if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN)) return g_variant_new_boolean (g_value_get_boolean (value)); } else if (G_VALUE_HOLDS_CHAR (value) || G_VALUE_HOLDS_UCHAR (value)) { if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE)) { if (G_VALUE_HOLDS_CHAR (value)) return g_variant_new_byte (g_value_get_char (value)); else return g_variant_new_byte (g_value_get_uchar (value)); } } else if (G_VALUE_HOLDS_INT (value) || G_VALUE_HOLDS_INT64 (value)) return g_settings_set_mapping_int (value, expected_type); else if (G_VALUE_HOLDS_DOUBLE (value)) return g_settings_set_mapping_float (value, expected_type); else if (G_VALUE_HOLDS_UINT (value) || G_VALUE_HOLDS_UINT64 (value)) return g_settings_set_mapping_unsigned_int (value, expected_type); else if (G_VALUE_HOLDS_STRING (value)) { if (g_value_get_string (value) == NULL) return NULL; else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING)) return g_variant_new_string (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING)) return g_variant_new_bytestring (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH)) return g_variant_new_object_path (g_value_get_string (value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE)) return g_variant_new_signature (g_value_get_string (value)); } else if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { if (g_value_get_boxed (value) == NULL) return NULL; return g_variant_new_strv ((const gchar **) g_value_get_boxed (value), -1); } else if (G_VALUE_HOLDS_ENUM (value)) { GEnumValue *enumval; GEnumClass *eclass; /* GParamSpecEnum holds a ref on the class so we just peek... */ eclass = g_type_class_peek (G_VALUE_TYPE (value)); enumval = g_enum_get_value (eclass, g_value_get_enum (value)); if (enumval) return g_variant_new_string (enumval->value_nick); else return NULL; } else if (G_VALUE_HOLDS_FLAGS (value)) { GVariantBuilder builder; GFlagsValue *flagsval; GFlagsClass *fclass; guint flags; fclass = g_type_class_peek (G_VALUE_TYPE (value)); flags = g_value_get_flags (value); g_variant_builder_init (&builder, G_VARIANT_TYPE ("as")); while (flags) { flagsval = g_flags_get_first_value (fclass, flags); if (flagsval == NULL) { g_variant_builder_clear (&builder); return NULL; } g_variant_builder_add (&builder, "s", flagsval->value_nick); flags &= ~flagsval->value; } return g_variant_builder_end (&builder); } type_string = g_variant_type_dup_string (expected_type); g_critical ("No GSettings bind handler for type \"%s\".", type_string); g_free (type_string); return NULL; }