static gpointer value_as_pointer (GValue *value) { if (g_value_fits_pointer (value)) return g_value_peek_pointer (value); if (G_VALUE_HOLDS_BOOLEAN (value)) return (void*) g_value_get_boolean (value); if (G_VALUE_HOLDS_CHAR (value)) return (void*) (gssize) g_value_get_char (value); if (G_VALUE_HOLDS_UCHAR (value)) return (void*) (gsize) g_value_get_uchar (value); if (G_VALUE_HOLDS_INT (value)) return (void*) g_value_get_int (value); if (G_VALUE_HOLDS_UINT (value)) return (void*) g_value_get_uint (value); if (G_VALUE_HOLDS_LONG (value)) return (void*) g_value_get_long (value); if (G_VALUE_HOLDS_ULONG (value)) return (void*) g_value_get_ulong (value); if (G_VALUE_HOLDS_FLOAT (value)) return (void*) (gssize) g_value_get_float (value); if (G_VALUE_HOLDS_DOUBLE (value)) return (void*) (gssize) g_value_get_double (value); if (G_VALUE_HOLDS_ENUM (value)) return (void*) (gssize) g_value_get_enum (value); if (G_VALUE_HOLDS_FLAGS (value)) return (void*) (gsize) g_value_get_flags (value); return (void*) 0x1373babe; }
static void value_text_edited (GtkCellRendererText * cell, const gchar * path, const gchar * new_text, GladeEditorProperty * eprop) { GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop); GtkTreeIter iter; gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number")); gint row; GNode *data_tree = NULL; GladeModelData *data; GValue *value; GladeProperty *property = glade_editor_property_get_property (eprop); if (!gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (eprop_data->store), &iter, path)) return; gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter, COLUMN_ROW, &row, -1); glade_property_get (property, &data_tree); /* if we are editing, then there is data in the datatree */ g_assert (data_tree); data_tree = glade_model_data_tree_copy (data_tree); data = glade_model_data_tree_get_data (data_tree, row, colnum); /* Untranslate string and update value in tree. */ if (G_VALUE_HOLDS_ENUM (&data->value) || G_VALUE_HOLDS_FLAGS (&data->value)) value = glade_utils_value_from_string (G_VALUE_TYPE (&data->value), glade_get_value_from_displayable (G_VALUE_TYPE (&data->value), new_text), glade_widget_get_project (glade_property_get_widget (property))); else value = glade_utils_value_from_string (G_VALUE_TYPE (&data->value), new_text, glade_widget_get_project (glade_property_get_widget (property))); g_value_copy (value, &data->value); g_value_unset (value); g_free (value); eprop_data->editing_row = row; eprop_data->editing_column = colnum; if (eprop_data->pending_data_tree) glade_model_data_tree_free (eprop_data->pending_data_tree); eprop_data->pending_data_tree = data_tree; g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop); }
static GObject * g_local_file_monitor_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *obj; GLocalFileMonitorClass *klass; GObjectClass *parent_class; GLocalFileMonitor *local_monitor; const gchar *filename = NULL; GFileMonitorFlags flags = 0; gint i; klass = G_LOCAL_FILE_MONITOR_CLASS (g_type_class_peek (G_TYPE_LOCAL_FILE_MONITOR)); parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass)); obj = parent_class->constructor (type, n_construct_properties, construct_properties); local_monitor = G_LOCAL_FILE_MONITOR (obj); for (i = 0; i < n_construct_properties; i++) { if (strcmp ("filename", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_STRING (construct_properties[i].value)); filename = g_value_get_string (construct_properties[i].value); } else if (strcmp ("flags", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_FLAGS (construct_properties[i].value)); flags = g_value_get_flags (construct_properties[i].value); } } g_warn_if_fail (filename != NULL); local_monitor->filename = g_strdup (filename); local_monitor->flags = flags; return obj; }
/* This function really ought not to be part of Amanda. In my (Ian's) opinion, serialization and deserialization should be a part of the GValue interface. But it's not, and here we are. */ gboolean g_value_set_from_string(GValue * val, char * string) { g_return_val_if_fail(val != NULL, FALSE); g_return_val_if_fail(G_IS_VALUE(val), FALSE); if (G_VALUE_HOLDS_BOOLEAN(val)) { return g_value_set_boolean_from_string(val, string); } else if (G_VALUE_HOLDS_INT(val)) { return g_value_set_int_from_string(val, string); } else if (G_VALUE_HOLDS_UINT(val)) { return g_value_set_uint_from_string(val, string); } else if (G_VALUE_HOLDS_UINT64(val)) { return g_value_set_uint64_from_string(val, string); } else if (G_VALUE_HOLDS_STRING(val)) { g_value_set_string(val, string); return TRUE; } else if (G_VALUE_HOLDS_FLAGS(val)) { return g_value_set_flags_from_string(val, string); } return TRUE; }
/** * Implements * org.gnome.glib.GValue.g_value_get_flags(long value) * called from * org.gnome.glib.GValue.getFlags(Value value) * called from * org.gnome.glib.Object.getPropertyFlags(String name) * * Extract the ordinal of an flag stored in a GValue of type G_TYPE_FLAGS. */ JNIEXPORT jint JNICALL Java_org_gnome_glib_GValue_g_1value_1get_1flags ( JNIEnv* env, jclass cls, jlong _value ) { GValue* value; guint num; // translate value value = (GValue*) _value; if (!G_VALUE_HOLDS_FLAGS(value)) { bindings_java_throw(env, "You've asked for the flags ordinal value of a GValue, but it's not a G_TYPE_FLAGS!"); return 0; } // call function num = g_value_get_flags(value); // and return return (jint) num; }
static GObject * g_local_directory_monitor_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *obj; GLocalDirectoryMonitorClass *klass; GObjectClass *parent_class; GLocalDirectoryMonitor *local_monitor; GFileMonitorFlags flags = 0; const gchar *dirname = NULL; gint i; klass = G_LOCAL_DIRECTORY_MONITOR_CLASS (g_type_class_peek (G_TYPE_LOCAL_DIRECTORY_MONITOR)); parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass)); obj = parent_class->constructor (type, n_construct_properties, construct_properties); local_monitor = G_LOCAL_DIRECTORY_MONITOR (obj); for (i = 0; i < n_construct_properties; i++) { if (strcmp ("dirname", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_STRING (construct_properties[i].value)); dirname = g_value_get_string (construct_properties[i].value); } if (strcmp ("flags", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_FLAGS (construct_properties[i].value)); flags = g_value_get_flags (construct_properties[i].value); } } local_monitor->dirname = g_strdup (dirname); local_monitor->flags = flags; if (!klass->mount_notify && (flags & G_FILE_MONITOR_WATCH_MOUNTS)) { #ifdef G_OS_WIN32 /*claim everything was mounted */ local_monitor->was_mounted = TRUE; #else GUnixMountEntry *mount; /* Emulate unmount detection */ mount = g_unix_mount_at (local_monitor->dirname, NULL); local_monitor->was_mounted = mount != NULL; if (mount) g_unix_mount_free (mount); local_monitor->mount_monitor = g_unix_mount_monitor_new (); g_signal_connect_object (local_monitor->mount_monitor, "mounts-changed", G_CALLBACK (mounts_changed), local_monitor, 0); #endif } return obj; }
gboolean _flags_in_gvalue(GValue* v) { return G_VALUE_HOLDS_FLAGS(v); }
gboolean glibsharp_value_holds_flags (GValue *value) { return G_VALUE_HOLDS_FLAGS (value); }
/** * g_strdup_value_contents: * @value: #GValue which contents are to be described. * * Return a newly allocated string, which describes the contents of a * #GValue. The main purpose of this function is to describe #GValue * contents for debugging output, the way in which the contents are * described may change between different GLib versions. * * Returns: Newly allocated string. */ gchar* g_strdup_value_contents (const GValue *value) { const gchar *src; gchar *contents; g_return_val_if_fail (G_IS_VALUE (value), NULL); if (G_VALUE_HOLDS_STRING (value)) { src = g_value_get_string (value); if (!src) contents = g_strdup ("NULL"); else { gchar *s = g_strescape (src, NULL); contents = g_strdup_printf ("\"%s\"", s); g_free (s); } } else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING)) { GValue tmp_value = { 0, }; gchar *s; g_value_init (&tmp_value, G_TYPE_STRING); g_value_transform (value, &tmp_value); s = g_strescape (g_value_get_string (&tmp_value), NULL); g_value_unset (&tmp_value); if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value)) contents = g_strdup_printf ("((%s) %s)", g_type_name (G_VALUE_TYPE (value)), s); else contents = g_strdup (s ? s : "NULL"); g_free (s); } else if (g_value_fits_pointer (value)) { gpointer p = g_value_peek_pointer (value); if (!p) contents = g_strdup ("NULL"); else if (G_VALUE_HOLDS_OBJECT (value)) contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p); else if (G_VALUE_HOLDS_PARAM (value)) contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p); else if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { GStrv strv = g_value_get_boxed (value); GString *tmp = g_string_new ("["); while (*strv != NULL) { gchar *escaped = g_strescape (*strv, NULL); g_string_append_printf (tmp, "\"%s\"", escaped); g_free (escaped); if (*++strv != NULL) g_string_append (tmp, ", "); } g_string_append (tmp, "]"); contents = g_string_free (tmp, FALSE); } else if (G_VALUE_HOLDS_BOXED (value)) contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p); else if (G_VALUE_HOLDS_POINTER (value)) contents = g_strdup_printf ("((gpointer) %p)", p); else contents = g_strdup ("???"); } else contents = g_strdup ("???"); return contents; }
gboolean g_settings_get_mapping (GValue *value, GVariant *variant, gpointer user_data) { if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN)) { if (!G_VALUE_HOLDS_BOOLEAN (value)) return FALSE; g_value_set_boolean (value, g_variant_get_boolean (variant)); return TRUE; } else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE)) { if (G_VALUE_HOLDS_UCHAR (value)) g_value_set_uchar (value, g_variant_get_byte (variant)); else if (G_VALUE_HOLDS_CHAR (value)) g_value_set_char (value, (gchar) g_variant_get_byte (variant)); else return FALSE; return TRUE; } else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) || g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) || g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64)) return g_settings_get_mapping_int (value, variant); else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE)) return g_settings_get_mapping_float (value, variant); else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) || g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) || g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64) || g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE)) return g_settings_get_mapping_unsigned_int (value, variant); else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) || g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE)) { if (G_VALUE_HOLDS_STRING (value)) { g_value_set_string (value, g_variant_get_string (variant, NULL)); return TRUE; } else if (G_VALUE_HOLDS_ENUM (value)) { GEnumClass *eclass; GEnumValue *evalue; const gchar *nick; /* GParamSpecEnum holds a ref on the class so we just peek... */ eclass = g_type_class_peek (G_VALUE_TYPE (value)); nick = g_variant_get_string (variant, NULL); evalue = g_enum_get_value_by_nick (eclass, nick); if (evalue) { g_value_set_enum (value, evalue->value); return TRUE; } g_warning ("Unable to lookup enum nick '%s' via GType\n", nick); return FALSE; } } else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as"))) { if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { g_value_take_boxed (value, g_variant_dup_strv (variant, NULL)); return TRUE; } else if (G_VALUE_HOLDS_FLAGS (value)) { GFlagsClass *fclass; GFlagsValue *fvalue; const gchar *nick; GVariantIter iter; guint flags = 0; fclass = g_type_class_peek (G_VALUE_TYPE (value)); g_variant_iter_init (&iter, variant); while (g_variant_iter_next (&iter, "&s", &nick)) { fvalue = g_flags_get_value_by_nick (fclass, nick); if (fvalue) flags |= fvalue->value; else { g_warning ("Unable to lookup flags nick '%s' via GType\n", nick); return FALSE; } } g_value_set_flags (value, flags); return TRUE; } } else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING)) { g_value_set_string (value, g_variant_get_bytestring (variant)); return TRUE; } g_critical ("No GSettings bind handler for type \"%s\".", g_variant_get_type_string (variant)); return FALSE; }
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; }