static gboolean gst_base_video_decoder_sink_setcaps (GstPad * pad, GstCaps * caps) { GstBaseVideoDecoder *base_video_decoder; GstBaseVideoDecoderClass *base_video_decoder_class; GstStructure *structure; const GValue *codec_data; GstVideoState *state; gboolean ret = TRUE; base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); base_video_decoder_class = GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); GST_DEBUG ("setcaps %" GST_PTR_FORMAT, caps); state = &base_video_decoder->state; gst_base_video_decoder_reset_state (state); structure = gst_caps_get_structure (caps, 0); gst_video_format_parse_caps (caps, NULL, &state->width, &state->height); gst_video_parse_caps_framerate (caps, &state->fps_n, &state->fps_d); gst_video_parse_caps_pixel_aspect_ratio (caps, &state->par_n, &state->par_d); gst_structure_get_boolean (structure, "interlaced", &state->interlaced); codec_data = gst_structure_get_value (structure, "codec_data"); if (codec_data && G_VALUE_TYPE (codec_data) == GST_TYPE_BUFFER) state->codec_data = gst_value_get_buffer (codec_data); if (base_video_decoder_class->set_sink_caps) ret = base_video_decoder_class->set_sink_caps (base_video_decoder, caps); g_object_unref (base_video_decoder); return ret; }
void _owr_deep_notify(GObject *object, GstObject *orig, GParamSpec *pspec, gpointer user_data) { GValue value = G_VALUE_INIT; gchar *str = NULL; GstObject *it; gchar *prevpath, *path; OWR_UNUSED(user_data); OWR_UNUSED(object); path = g_strdup(""); for (it = orig; GST_IS_OBJECT(it); it = GST_OBJECT_PARENT(it)) { prevpath = path; path = g_strjoin("/", GST_OBJECT_NAME(it), prevpath, NULL); g_free(prevpath); } if (pspec->flags & G_PARAM_READABLE) { g_value_init(&value, pspec->value_type); g_object_get_property(G_OBJECT(orig), pspec->name, &value); if (G_VALUE_TYPE(&value) == GST_TYPE_CAPS) str = gst_caps_to_string(gst_value_get_caps(&value)); else if (G_VALUE_HOLDS_STRING(&value)) str = g_value_dup_string(&value); else str = gst_value_serialize(&value); GST_INFO_OBJECT(object, "%s%s = %s\n", path, pspec->name, str); g_free(str); g_value_unset(&value); } else GST_INFO_OBJECT(object, "Parameter %s not readable in %s.", pspec->name, path); g_free(path); }
void conting_attributes_get_valist(ContingAttributes *self, const gchar *first, va_list ap) { g_return_if_fail(self != NULL && CONTING_IS_ATTRIBUTES(self)); while (first) { gpointer *pointer; const GValue *value; pointer = va_arg(ap, gpointer *); value = conting_attributes_get_value(self, first); if (value == NULL) { *pointer = NULL; } else { switch (G_VALUE_TYPE(value)) { case G_TYPE_INT: *((gint *) pointer) = g_value_get_int(value); break; case G_TYPE_DOUBLE: *((gdouble *) pointer) = g_value_get_double(value); break; case G_TYPE_STRING: *((const gchar **) pointer) = g_value_get_string(value); break; case G_TYPE_POINTER: default: *pointer = g_value_get_pointer(value); break; } } first = va_arg(ap, const gchar *); } }
static void enum_flags_format_cell_data (GtkCellLayout * cell_layout, GtkCellRenderer * cell, GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data) { gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number")); GValue value = { 0, }; gchar *string; gtk_tree_model_get_value (tree_model, iter, NUM_COLUMNS + colnum, &value); string = glade_utils_string_from_value (&value); g_object_set (cell, "text", string && string[0] ? glade_get_displayable_value (G_VALUE_TYPE (&value), string) : "", NULL); g_free (string); g_value_unset (&value); }
static gchar * g_value_to_string (const GValue * val) { gchar *ret = NULL; if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) { GstBuffer *buf = gst_value_get_buffer (val); GstMapInfo map; gst_buffer_map (buf, &map, GST_MAP_READ); ret = g_base64_encode (map.data, map.size); gst_buffer_unmap (buf, &map); } else { GValue s = { 0, }; g_value_init (&s, G_TYPE_STRING); if (g_value_transform (val, &s)) { ret = g_value_dup_string (&s); g_value_unset (&s); } } return ret; }
static GVariant* pd_color_to_string_mapping (const GValue *value, const GVariantType *expected_type, gpointer user_data) { GVariant *variant = NULL; GdkColor *color; gchar *hex_val; g_return_val_if_fail (G_VALUE_TYPE (value) == GDK_TYPE_COLOR, NULL); g_return_val_if_fail (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING), NULL); color = g_value_get_boxed (value); hex_val = g_strdup_printf ("#%02X%02X%02X", color->red / 256, color->green / 256, color->blue / 256); variant = g_variant_new_string (hex_val); g_free (hex_val); return variant; }
gboolean audacious_dbus_string(DBusGProxy *proxy, const char *method, int pos, const char *arg, char* dest) { GValue val; memset(&val, 0, sizeof(GValue)); GError *error = 0; if (!dbus_g_proxy_call_with_timeout(proxy, method, DBUS_TIMEOUT, &error, G_TYPE_UINT, pos, G_TYPE_STRING, arg, G_TYPE_INVALID, G_TYPE_VALUE, &val, G_TYPE_INVALID)) { trace("Failed to make dbus call %s: %s", method, error->message); return FALSE; } if (G_VALUE_TYPE(&val) == G_TYPE_STRING) { strncpy(dest, g_value_get_string(&val), STRLEN); dest[STRLEN-1] = 0; } g_value_unset(&val); return TRUE; }
/** * g_value_array_insert: * @value_array: #GValueArray to add an element to * @index_: insertion position, must be <= value_array->;n_values * @value: (allow-none): #GValue to copy into #GValueArray, or %NULL * * Insert a copy of @value at specified position into @value_array. If @value * is %NULL, an uninitialized value is inserted. * * Returns: (transfer none): the #GValueArray passed in as @value_array * * Deprecated: 2.32: Use #GArray and g_array_insert_val() instead. */ GValueArray* g_value_array_insert (GValueArray *value_array, guint index, const GValue *value) { guint i; g_return_val_if_fail (value_array != NULL, NULL); g_return_val_if_fail (index <= value_array->n_values, value_array); i = value_array->n_values; value_array_grow (value_array, value_array->n_values + 1, FALSE); if (index + 1 < value_array->n_values) memmove (value_array->values + index + 1, value_array->values + index, (i - index) * sizeof (value_array->values[0])); memset (value_array->values + index, 0, sizeof (value_array->values[0])); if (value) { g_value_init (value_array->values + index, G_VALUE_TYPE (value)); g_value_copy (value, value_array->values + index); } return value_array; }
void gsf_doc_prop_glue_get_val (GsfDocProp const *prop, GType *type, GValue *value) { GValue const *prop_val; if (prop == NULL) return; prop_val = gsf_doc_prop_get_val (prop); if (prop_val != NULL && G_IS_VALUE (prop_val)) { *type = G_VALUE_TYPE (prop_val); g_value_init (value, *type); g_value_copy (prop_val, value); /* printf ("Type == %d, G_TYPE_STRING=%d, G_VALUE_TYPE (prop_val)=%d\n", *type, G_TYPE_STRING, G_VALUE_TYPE (prop_val)); */ } }
static gboolean set_param_from_value (const TpCMParamSpec *paramspec, GValue *value, const TpCMParamSetter set_param, void *params, GError **error) { if (G_VALUE_TYPE (value) != paramspec->gtype) { DEBUG ("expected type %s for parameter %s, got %s", g_type_name (paramspec->gtype), paramspec->name, G_VALUE_TYPE_NAME (value)); g_set_error (error, TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "expected type %s for account parameter %s, got %s", g_type_name (paramspec->gtype), paramspec->name, G_VALUE_TYPE_NAME (value)); return FALSE; } set_param (paramspec, value, params); return TRUE; }
GValue *backend_command_get_key_value(const gchar * key, GValue * value) { gchar cmdBuf[COMMAND_BUFFER_SIZE]; gchar *cKey = mkdg_backend_get_key(backend, NULL, key, NULL); #ifdef USE_GSETTINGS g_snprintf(cmdBuf, COMMAND_BUFFER_SIZE, "gsettings get %s %s", QUOTE_ME(PROJECT_SCHEMA_ID), cKey); #else g_snprintf(cmdBuf, COMMAND_BUFFER_SIZE, "gconftool-2 --get %s/%s", QUOTE_ME(PROJECT_GCONF2_SCHEMA_DIR), cKey); #endif gchar *retStr = command_run_obtain_output(cmdBuf); #ifdef USE_GSETTINGS /* gsettings prepend 'uint32 ' before actual value */ if (G_VALUE_TYPE(value) == G_TYPE_UINT) { gint offset = strlen("uint32 "); retStr += offset; } #endif mkdg_g_value_from_string(value, retStr); return value; }
static gboolean build_field_template (GQuark field_id, const GValue * value, gpointer user_data) { GString *s = (GString *) user_data; const GstStructure *sub; GValue template_value = { 0, }; GType type = G_TYPE_INVALID; GstTracerValueFlags flags = GST_TRACER_VALUE_FLAGS_NONE; gboolean res; if (G_VALUE_TYPE (value) != GST_TYPE_STRUCTURE) { GST_WARNING ("expected field of type GstStructure, but %s is %s", g_quark_to_string (field_id), G_VALUE_TYPE_NAME (value)); return FALSE; } sub = gst_value_get_structure (value); gst_structure_get (sub, "type", G_TYPE_GTYPE, &type, "flags", GST_TYPE_TRACER_VALUE_FLAGS, &flags, NULL); if (flags & GST_TRACER_VALUE_FLAGS_OPTIONAL) { gchar *opt_name = g_strconcat ("have-", g_quark_to_string (field_id), NULL); /* add a boolean field, that indicates the presence of the next field */ g_value_init (&template_value, G_TYPE_BOOLEAN); priv__gst_structure_append_template_to_gstring (g_quark_from_string (opt_name), &template_value, s); g_value_unset (&template_value); g_free (opt_name); } g_value_init (&template_value, type); res = priv__gst_structure_append_template_to_gstring (field_id, &template_value, s); g_value_unset (&template_value); return res; }
static void __set_expression_value (GValue *dest, GValue *src) { gchar *str; switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (src))) { case G_TYPE_STRING: str = g_strdup_printf ("'%s'", g_value_get_string (src)); break; case G_TYPE_UINT: str = g_strdup_printf ("%d", g_value_get_uint (src)); break; case G_TYPE_INT: str = g_strdup_printf ("%d", g_value_get_int (src)); break; case G_TYPE_FLOAT: str = g_strdup_printf ("%.04f", g_value_get_float (src)); break; case G_TYPE_BOOLEAN: str = g_strdup_printf ("%d", g_value_get_boolean (src)); break; case G_TYPE_BOXED: g_print ("BOXED type not implemented \n"); break; default: break; } g_value_take_string (dest, str); }
int main (int argc, char *argv[]) { GskXmlProcessor *xml_processor; GskXmlConfig *config; GValue value = { 0 }; int i; gsk_init_without_threads (&argc, &argv); config = gsk_xml_config_new (NULL); g_return_val_if_fail (config, -1); gsk_xml_config_add_type_test (config, return_true, NULL, NULL); gsk_xml_config_set_loader (config, gsk_xml_loader_introspective, NULL, NULL); xml_processor = gsk_xml_processor_new (config, G_TYPE_OBJECT, handle_value, &value, NULL); g_return_val_if_fail (xml_processor, -1); for (i = 0; i < G_N_ELEMENTS (tests); ++i) { TestObject *object; char *xml; if (!gsk_xml_processor_input (xml_processor, tests[i], strlen (tests[i]))) g_error ("error parsing XML '%s'", tests[i]); g_return_val_if_fail (G_VALUE_TYPE (&value) == G_TYPE_OBJECT, -1); g_return_val_if_fail (TEST_IS_OBJECT (g_value_get_object (&value)), -1); object = TEST_OBJECT (g_value_get_object (&value)); xml = test_object_get_xml (object); g_return_val_if_fail (strcmp (xml, tests[i]) == 0, -1); g_free (xml); g_value_unset (&value); } gsk_xml_processor_destroy (xml_processor); gsk_xml_config_unref (config); return 0; }
void moto_variation_save_param(MotoVariation *self, MotoParam *p) { MotoVariationPriv *priv = MOTO_VARIATION_GET_PRIVATE(self); GValue none = {0,}; guint id = moto_param_get_id(p); GValue *pv = moto_param_get_value(p); GType pt = G_VALUE_TYPE(pv); GHashTable *params = priv->params; GValue *v = (GValue *)g_hash_table_lookup(params, &id); if( ! v) { v = g_slice_new(GValue); *v = none; g_value_init(v, pt); guint *key = g_slice_new(guint); *key = id; g_hash_table_insert(params, key, v); } else if(g_type_is_a(pt, G_TYPE_OBJECT)) { GObject *o = g_value_get_object(v); if(o) g_object_weak_unref(o, (GWeakNotify)null_value, v); } if(g_type_is_a(pt, G_TYPE_OBJECT)) { GObject *o = moto_param_get_object(p); if(o) g_object_weak_ref(o, (GWeakNotify)null_value, v); } g_value_copy(pv, v); }
/* Same as above but handles size == 0 as not available */ void size_na_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data) { const guint index = GPOINTER_TO_UINT(user_data); guint64 size; GValue value = { 0 }; gtk_tree_model_get_value(model, iter, index, &value); switch (G_VALUE_TYPE(&value)) { case G_TYPE_ULONG: size = g_value_get_ulong(&value); break; case G_TYPE_UINT64: size = g_value_get_uint64(&value); break; default: g_assert_not_reached(); } g_value_unset(&value); if (size == 0) { char *str = g_strdup_printf ("<i>%s</i>", _("N/A")); g_object_set(renderer, "markup", str, NULL); g_free(str); } else { char *str = procman::format_size(size); g_object_set(renderer, "text", str, NULL); g_free(str); } }
static GdaRow * create_new_row (GdaDataAccessWrapper *model) { gint i; GdaRow *row; row = gda_row_new (model->priv->nb_cols); for (i = 0; i < model->priv->nb_cols; i++) { GdaHolder *holder; GValue *dest; dest = gda_row_get_value (row, i); if (model->priv->rows_mapping) holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, model->priv->rows_mapping [i]); else holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, i); if (holder) { const GValue *cvalue = gda_holder_get_value (holder); if (cvalue) { gda_value_reset_with_type (dest, G_VALUE_TYPE ((GValue *) cvalue)); g_value_copy (cvalue, dest); } else gda_value_set_null (dest); } else gda_row_invalidate_value (row, dest); } gint *ptr; ptr = g_new (gint, 1); *ptr = model->priv->iter_row; g_hash_table_insert (model->priv->rows, ptr, row); /*g_print ("%s(%d)\n", __FUNCTION__, model->priv->iter_row);*/ return row; }
gboolean my_foreach_func(GQuark field_id, const GValue *value, gpointer user_data) { my_foreach_state &state = *((my_foreach_state *)user_data); QString name = QString::fromLatin1(g_quark_to_string(field_id)); if(G_VALUE_TYPE(value) == G_TYPE_STRING && state.whitelist->contains(name)) { QString svalue = QString::fromLatin1(g_value_get_string(value)); // FIXME: is there a better way to detect when we should do this conversion? if(name == "configuration" && (state.out->name == "THEORA" || state.out->name == "VORBIS")) { QByteArray config = QByteArray::fromBase64(svalue.toLatin1()); svalue = hexEncode(config); } PPayloadInfo::Parameter i; i.name = name; i.value = svalue; state.list->append(i); } return TRUE; }
static gchar * g_value_to_string (const GValue * val) { if (G_VALUE_TYPE (val) == GST_TYPE_BUFFER) { const GstBuffer *buf = gst_value_get_buffer (val); gchar *ret = g_base64_encode (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); return ret; } else { GValue s = { 0, }; gchar *ret; g_value_init (&s, G_TYPE_STRING); if (!g_value_transform (val, &s)) { return NULL; } ret = g_value_dup_string (&s); g_value_unset (&s); return ret; } }
/** * cryptui_key_store_check_toggled: * @ckstore: a libcryptui key store * @view: a GtkTreeView * @iter: a GtkTreeIter * * Gets whether the check at iter is toggled */ void cryptui_key_store_check_toggled (CryptUIKeyStore *ckstore, GtkTreeView *view, GtkTreeIter *iter) { GtkTreeSelection *selection; gboolean prev = FALSE; GtkTreeIter base; GValue v; memset (&v, 0, sizeof(v)); g_return_if_fail (iter != NULL); /* We get notified in filtered coordinates, we have to convert those to base */ key_store_get_base_iter (ckstore, iter, &base); gtk_tree_model_get_value (GTK_TREE_MODEL (ckstore->priv->store), &base, CRYPTUI_KEY_STORE_CHECK, &v); if(G_VALUE_TYPE (&v) == G_TYPE_BOOLEAN) prev = g_value_get_boolean (&v); g_value_unset (&v); gtk_tree_store_set (GTK_TREE_STORE (ckstore->priv->store), &base, CRYPTUI_KEY_STORE_CHECK, prev ? FALSE : TRUE, -1); selection = gtk_tree_view_get_selection (view); g_signal_emit_by_name (selection, "changed"); }
static gboolean ct_text_set_tooltip (DonnaColumnType *ct, gpointer _data, guint index, DonnaNode *node, GtkTooltip *tooltip) { struct tv_col_data *data = _data; DonnaNodeHasValue has; GValue value = G_VALUE_INIT; const gchar *s; donna_node_get (node, FALSE, (data->property_tooltip) ? data->property_tooltip : data->property, &has, &value, NULL); if (has != DONNA_NODE_VALUE_SET) return FALSE; if (G_VALUE_TYPE (&value) != G_TYPE_STRING) { g_value_unset (&value); return FALSE; } /* don't show tooltip w/ an empty string */ s = g_value_get_string (&value); if (s) { skip_blank (s); if (*s != '\0') gtk_tooltip_set_text (tooltip, g_value_get_string (&value)); else s = NULL; } g_value_unset (&value); return !!s; }
JNIEXPORT jlong JNICALL Java_org_gnome_glib_GValue_g_1value_1get_1pixbuf ( JNIEnv* env, jclass cls, jlong _value ) { GValue* value; GdkPixbuf* pixbuf; // translate value value = (GValue*) _value; if (G_VALUE_TYPE(value) != GDK_TYPE_PIXBUF) { bindings_java_throw(env, "You've asked for the GdkPixbuf within a GValue, but it's not a GDK_TYPE_PIXBUF!"); return 0L; } // call function pixbuf = g_value_get_object(value); // and return return (jlong) pixbuf; }
static HaskellObj #ifdef GHC_RTS_USES_CAPABILITY gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) { #else gtk2hs_value_as_haskellobj(const GValue *value) { #endif switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) return rts_mkPtr(CAP g_value_get_object(value)); else break; case G_TYPE_CHAR: return rts_mkChar(CAP g_value_get_schar(value)); case G_TYPE_UCHAR: return rts_mkChar(CAP g_value_get_uchar(value)); case G_TYPE_BOOLEAN: return rts_mkBool(CAP g_value_get_boolean(value)); case G_TYPE_INT: return rts_mkInt(CAP g_value_get_int(value)); case G_TYPE_UINT: return rts_mkWord(CAP g_value_get_uint(value)); case G_TYPE_LONG: return rts_mkInt(CAP g_value_get_long(value)); case G_TYPE_ULONG: return rts_mkWord(CAP g_value_get_ulong(value)); /* case G_TYPE_INT64: return rts_mkInt64(CAP g_value_get_int64(value)); case G_TYPE_UINT64: return rts_mkWord64(CAP g_value_get_uint64(value)); */ case G_TYPE_ENUM: return rts_mkInt(CAP g_value_get_enum(value)); case G_TYPE_FLAGS: return rts_mkWord(CAP g_value_get_enum(value)); case G_TYPE_FLOAT: return rts_mkFloat(CAP g_value_get_float(value)); case G_TYPE_DOUBLE: return rts_mkDouble(CAP g_value_get_double(value)); case G_TYPE_STRING: return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */ case G_TYPE_POINTER: return rts_mkPtr(CAP g_value_get_pointer(value)); case G_TYPE_BOXED: return rts_mkPtr(CAP g_value_get_boxed(value)); case G_TYPE_PARAM: return rts_mkPtr(CAP g_value_get_param(value)); case G_TYPE_OBJECT: return rts_mkPtr(CAP g_value_get_object(value)); } g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); } void gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) { switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INVALID: case G_TYPE_NONE: return; case G_TYPE_INTERFACE: /* we only handle interface types that have a GObject prereq */ if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) { g_value_set_object(value, rts_getPtr(obj)); } else { break; } return; case G_TYPE_CHAR: g_value_set_schar(value, rts_getChar(obj)); return; case G_TYPE_UCHAR: g_value_set_schar(value, rts_getChar(obj)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(value, rts_getBool(obj)); return; case G_TYPE_INT: g_value_set_int(value, rts_getInt(obj)); return; case G_TYPE_UINT: g_value_set_uint(value, rts_getWord(obj)); return; case G_TYPE_LONG: g_value_set_long(value, rts_getInt(obj)); return; case G_TYPE_ULONG: g_value_set_ulong(value, rts_getWord(obj)); return; /* case G_TYPE_INT64: g_value_set_int64(value, rts_getInt64(obj)); return; case G_TYPE_UINT64: g_value_set_uint64(value, rts_getWord64(obj)); return; */ case G_TYPE_ENUM: g_value_set_enum(value, rts_getInt(obj)); return; case G_TYPE_FLAGS: g_value_set_flags(value, rts_getInt(obj)); return; case G_TYPE_FLOAT: g_value_set_float(value, rts_getFloat(obj)); return; case G_TYPE_DOUBLE: g_value_set_double(value, rts_getDouble(obj)); return; case G_TYPE_STRING: g_value_set_string(value, rts_getPtr(obj)); return; case G_TYPE_POINTER: g_value_set_pointer(value, rts_getPtr(obj)); return; /* case G_TYPE_BOXED: { g_value_set_boxed(value, obj); break; } case G_TYPE_PARAM: g_value_set_param(value, (obj)); break; */ case G_TYPE_OBJECT: g_value_set_object(value, rts_getPtr(obj)); return; } g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); }
void _gtk_tree_data_list_value_to_node (GtkTreeDataList *list, GValue *value) { switch (get_fundamental_type (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: list->data.v_int = g_value_get_boolean (value); break; case G_TYPE_CHAR: list->data.v_char = g_value_get_schar (value); break; case G_TYPE_UCHAR: list->data.v_uchar = g_value_get_uchar (value); break; case G_TYPE_INT: list->data.v_int = g_value_get_int (value); break; case G_TYPE_UINT: list->data.v_uint = g_value_get_uint (value); break; case G_TYPE_LONG: list->data.v_long = g_value_get_long (value); break; case G_TYPE_ULONG: list->data.v_ulong = g_value_get_ulong (value); break; case G_TYPE_INT64: list->data.v_int64 = g_value_get_int64 (value); break; case G_TYPE_UINT64: list->data.v_uint64 = g_value_get_uint64 (value); break; case G_TYPE_ENUM: list->data.v_int = g_value_get_enum (value); break; case G_TYPE_FLAGS: list->data.v_uint = g_value_get_flags (value); break; case G_TYPE_POINTER: list->data.v_pointer = g_value_get_pointer (value); break; case G_TYPE_FLOAT: list->data.v_float = g_value_get_float (value); break; case G_TYPE_DOUBLE: list->data.v_double = g_value_get_double (value); break; case G_TYPE_STRING: g_free (list->data.v_pointer); list->data.v_pointer = g_value_dup_string (value); break; case G_TYPE_OBJECT: if (list->data.v_pointer) g_object_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_object (value); break; case G_TYPE_BOXED: if (list->data.v_pointer) g_boxed_free (G_VALUE_TYPE (value), list->data.v_pointer); list->data.v_pointer = g_value_dup_boxed (value); break; case G_TYPE_VARIANT: if (list->data.v_pointer) g_variant_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_variant (value); break; default: g_warning ("%s: Unsupported type (%s) stored.", G_STRLOC, g_type_name (G_VALUE_TYPE (value))); break; } }
static gboolean compare_record_property (DMAPRecord * record, const gchar * property_name, const gchar * property_value) { GParamSpec *pspec; GValue value = { 0, }; /* Note that this string belongs to value and will not be freed explicitely. */ const gchar *str_value; gboolean accept; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (record), property_name); if (pspec == NULL) // Can't find the property in this record, so don't accept it. return FALSE; // Get the property value as a GValue set to the type of this // property. g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property (G_OBJECT (record), property_name, &value); if (G_VALUE_HOLDS_STRING (&value)) { str_value = g_value_get_string (&value); } else if (G_VALUE_HOLDS_BOOLEAN (&value)) { g_debug ("Compare %s (boolean): %d %s", property_name, g_value_get_boolean (&value), property_value); accept = (g_value_get_boolean (&value) && g_strcmp0 (property_value, "1") == 0); g_value_unset (&value); return accept; } else if (g_value_type_transformable (G_VALUE_TYPE (&value), G_TYPE_LONG)) { // Prefer integer conversion. GValue dest = { 0, }; g_value_init (&dest, G_TYPE_LONG); if (!g_value_transform (&value, &dest)) { g_warning ("Failed to convert value into long for property %s", property_name); g_value_unset (&value); return FALSE; } g_debug ("Compare %s (long): %ld %s", property_name, g_value_get_long (&dest), property_value); accept = (g_value_get_long (&dest) == strtol (property_value, NULL, 10)); g_value_unset (&value); return accept; } else if (g_value_type_transformable (G_VALUE_TYPE (&value), G_TYPE_STRING)) { // Use standard transform functions from GLib (note that these // functions are unreliable and known cases should be handled // above). GValue dest; g_value_init (&dest, G_TYPE_STRING); if (!g_value_transform (&value, &dest)) { g_warning ("Failed to convert value into string for property %s", property_name); g_value_unset (&value); return FALSE; } str_value = g_value_dup_string (&dest); g_value_reset (&value); //Sets the string to value so that it will be freed later. g_value_take_string (&value, (gchar *) str_value); g_value_unset (&dest); } else { g_warning ("Attempt to compare unhandled type"); g_value_unset (&value); return FALSE; } // Only arrive here if we are handling strings. g_debug ("Compare %s (string): %s %s", property_name, str_value, property_value); if (str_value != NULL && property_value != NULL && g_ascii_strcasecmp (str_value, property_value) == 0) { accept = TRUE; } else if (str_value == NULL && property_value == NULL) { accept = TRUE; } else { accept = FALSE; } // This will destroy str_value since it belongs to value. g_value_unset (&value); return accept; }
/* * COMMAND: <gda_report_if> * * Creates a copy of the children of the <gda_report_if_true> or <gda_report_if_false> nodes depending on the * result of the execution of the expression * * uses node's contents: yes * requested attributes: none */ static gboolean command_gda_report_if (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes, RunContext *context, GError **error) { GValue *value; gboolean expr_is_true = FALSE; xmlChar *prop; prop = xmlGetProp (node, BAD_CAST "expr"); if (!prop) { g_set_error (error, 0, 0, "%s", _("No expression specified")); return FALSE; } /* evaluate expression as boolean */ value = evaluate_expression (engine, context, (const gchar *) prop, error); if (!value) return FALSE; xmlFree (prop); if (value && !gda_value_is_null (value)) { if (G_VALUE_TYPE (value) == G_TYPE_BOOLEAN) expr_is_true = g_value_get_boolean (value); else { GValue *trans; trans = gda_value_new (G_TYPE_BOOLEAN); if (g_value_transform (value, trans)) { expr_is_true = g_value_get_boolean (trans); gda_value_free (trans); } else { gda_value_free (trans); g_set_error (error, 0, 0, _("Cannot cast value from type '%s' to type '%s'"), g_type_name (G_VALUE_TYPE (value)), g_type_name (G_TYPE_BOOLEAN)); return FALSE; } } gda_value_free (value); } /*g_print ("IF Expression evaluates to %d\n", expr_is_true);*/ /* find the correct sub node: <gda_report_if_true> or <gda_report_if_false> */ gchar *sub_node_name; xmlNodePtr sub_node; sub_node_name = expr_is_true ? "gda_report_if_true" : "gda_report_if_false"; for (sub_node = node->children; sub_node; sub_node = sub_node->next) { if (!strcmp ((gchar *) sub_node->name, sub_node_name)) { if (!real_run_at_node (engine, sub_node->children, context, error)) return FALSE; else { xmlNodePtr child; for (child = sub_node->children; child; child = sub_node->children) { xmlUnlinkNode (child); *created_nodes = g_slist_prepend (*created_nodes, child); } } } } *created_nodes = g_slist_reverse (*created_nodes); return TRUE; }
/* * value_to_node * * Converts @value to a string */ static xmlNodePtr value_to_node (GdaReportEngine *engine, G_GNUC_UNUSED RunContext *context, const GValue *value, GdaSet *options) { xmlNodePtr retnode = NULL; GdaHolder *converter = NULL; if (options) converter = gda_set_get_holder (options, "converter"); if (!value || gda_value_is_null (value)) retnode = xmlNewText (BAD_CAST ""); else if ((G_VALUE_TYPE (value) == GDA_TYPE_BINARY) || (G_VALUE_TYPE (value) == GDA_TYPE_BLOB)) { TO_IMPLEMENT; retnode = xmlNewText (BAD_CAST _("Binary data")); } else { GdaDataHandler *dh; gchar *str; if (!data_handlers) { /* initialize the internal data handlers */ data_handlers = g_hash_table_new_full (gtype_hash, gtype_equal, NULL, (GDestroyNotify) g_object_unref); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT64, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT64, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_BOOLEAN, gda_handler_boolean_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DATE, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DOUBLE, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_NUMERIC, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_FLOAT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_SHORT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_USHORT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_STRING, gda_handler_string_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIME, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIMESTAMP, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_CHAR, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UCHAR, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_ULONG, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_LONG, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_GTYPE, gda_handler_type_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT, gda_handler_numerical_new ()); } gboolean converted = FALSE; dh = g_hash_table_lookup (data_handlers, (gpointer) G_VALUE_TYPE (value)); if (dh) str = gda_data_handler_get_str_from_value (dh, value); else str = gda_value_stringify (value); if (converter) { const GValue *cvalue; cvalue = gda_holder_get_value (converter); if ((G_VALUE_TYPE (cvalue) == G_TYPE_STRING) && g_value_get_string (cvalue)) { gchar **array; array = g_strsplit (g_value_get_string (cvalue), "::", 0); if (array[0] && !strcmp (array[0], "richtext")) { if (array[1] && !strcmp (array[1], "docbook")) { retnode = xmlNewNode (NULL, BAD_CAST "para"); parse_rich_text_to_docbook (engine, retnode, str); converted = TRUE; } else if (array[1] && !strcmp (array[1], "html")) { retnode = xmlNewNode (NULL, BAD_CAST "p"); parse_rich_text_to_html (engine, retnode, str); converted = TRUE; } } } } if (!converted) retnode = xmlNewText (BAD_CAST (str ? str : "")); g_free (str); } return retnode; }
static void gtk2hs_closure_marshal(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data) { Gtk2HsClosure *hc = (Gtk2HsClosure *)closure; HaskellObj call, ret; #ifdef GHC_RTS_USES_CAPABILITY Capability *cap; #else SchedulerStatus cap; #endif guint i; WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): about to run callback, n_param_values=%d", hc->callback, n_param_values)); #ifdef GHC_RTS_USES_CAPABILITY cap = rts_lock(); #else rts_lock(); #endif call = (StgClosure *)deRefStablePtr(hc->callback); /* construct the function call */ for (i = 0; i < n_param_values; i++) { WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): param_values[%d]=%s :: %s", hc->callback, i, g_strdup_value_contents(¶m_values[i]), g_type_name(G_VALUE_TYPE(¶m_values[i])))); call = rts_apply(CAP call, gtk2hs_value_as_haskellobj(CAP ¶m_values[i])); } WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): about to rts_evalIO", hc->callback)); /* perform the call */ #if __GLASGOW_HASKELL__>=704 rts_evalIO(&cap, rts_apply(CAP (HaskellObj)runIO_closure, call),&ret); #else cap=rts_evalIO(CAP rts_apply(CAP (HaskellObj)runIO_closure, call),&ret); #endif WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): about to rts_checkSchedStatus", hc->callback)); /* barf if anything went wrong */ /* TODO: pass a sensible value for call site so we get better error messages */ /* or perhaps we can propogate any error? */ rts_checkSchedStatus("gtk2hs_closure_marshal", cap); WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): ret=%p", hc->callback, ret)); if (return_value) { WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): return_value :: %s, ret=%p, UNTAG_CLOSURE(ret)=%p", hc->callback, /* g_strdup_value_contents(return_value), */ g_type_name(G_VALUE_TYPE(return_value)), ret, UNTAG_CLOSURE(ret))); gtk2hs_value_from_haskellobj(return_value, ret); } #ifdef GHC_RTS_USES_CAPABILITY rts_unlock(cap); #else rts_unlock(); #endif WHEN_DEBUG(g_debug("gtk2hs_closure_marshal(%p): done running callback", hc->callback)); }
static void write_setting_value (NMSetting *setting, const char *key, const GValue *value, GParamFlags flag, gpointer user_data) { GKeyFile *file = (GKeyFile *) user_data; const char *setting_name; GType type = G_VALUE_TYPE (value); KeyWriter *writer = &key_writers[0]; GParamSpec *pspec; /* Setting name gets picked up from the keyfile's section name instead */ if (!strcmp (key, NM_SETTING_NAME)) return; /* Don't write the NMSettingConnection object's 'read-only' property */ if ( NM_IS_SETTING_CONNECTION (setting) && !strcmp (key, NM_SETTING_CONNECTION_READ_ONLY)) return; setting_name = nm_setting_get_name (setting); /* If the value is the default value, remove the item from the keyfile */ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), key); if (pspec) { if (g_param_value_defaults (pspec, (GValue *) value)) { g_key_file_remove_key (file, setting_name, key, NULL); return; } } /* Look through the list of handlers for non-standard format key values */ while (writer->setting_name) { if (!strcmp (writer->setting_name, setting_name) && !strcmp (writer->key, key)) { (*writer->writer) (file, setting, key, value); return; } writer++; } if (type == G_TYPE_STRING) { const char *str; str = g_value_get_string (value); if (str) g_key_file_set_string (file, setting_name, key, str); } else if (type == G_TYPE_UINT) g_key_file_set_integer (file, setting_name, key, (int) g_value_get_uint (value)); else if (type == G_TYPE_INT) g_key_file_set_integer (file, setting_name, key, g_value_get_int (value)); else if (type == G_TYPE_UINT64) { char *numstr; numstr = g_strdup_printf ("%" G_GUINT64_FORMAT, g_value_get_uint64 (value)); g_key_file_set_value (file, setting_name, key, numstr); g_free (numstr); } else if (type == G_TYPE_BOOLEAN) { g_key_file_set_boolean (file, setting_name, key, g_value_get_boolean (value)); } else if (type == G_TYPE_CHAR) { g_key_file_set_integer (file, setting_name, key, (int) g_value_get_char (value)); } else if (type == DBUS_TYPE_G_UCHAR_ARRAY) { GByteArray *array; array = (GByteArray *) g_value_get_boxed (value); if (array && array->len > 0) { int *tmp_array; int i; tmp_array = g_new (gint, array->len); for (i = 0; i < array->len; i++) tmp_array[i] = (int) array->data[i]; g_key_file_set_integer_list (file, setting_name, key, tmp_array, array->len); g_free (tmp_array); } } else if (type == DBUS_TYPE_G_LIST_OF_STRING) { GSList *list; GSList *iter; list = (GSList *) g_value_get_boxed (value); if (list) { char **array; int i = 0; array = g_new (char *, g_slist_length (list)); for (iter = list; iter; iter = iter->next) array[i++] = iter->data; g_key_file_set_string_list (file, setting_name, key, (const gchar **const) array, i); g_free (array); } } else if (type == DBUS_TYPE_G_MAP_OF_STRING) {
static void contact_widget_location_update (EmpathyContactWidget *information) { GHashTable *location; GValue *value; gdouble lat = 0.0, lon = 0.0; gboolean has_position = TRUE; GtkWidget *label; guint row = 0; GHashTableIter iter; gpointer key, pvalue; if (!(information->flags & EMPATHY_CONTACT_WIDGET_SHOW_LOCATION)) { gtk_widget_hide (information->vbox_location); return; } location = empathy_contact_get_location (information->contact); if (location == NULL || g_hash_table_size (location) == 0) { gtk_widget_hide (information->vbox_location); return; } value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT); if (value == NULL) has_position = FALSE; else lat = g_value_get_double (value); value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON); if (value == NULL) has_position = FALSE; else lon = g_value_get_double (value); value = g_hash_table_lookup (location, EMPATHY_LOCATION_TIMESTAMP); if (value == NULL) gtk_label_set_markup (GTK_LABEL (information->label_location), _("<b>Location</b>")); else { gchar *user_date; gchar *text; gint64 stamp; time_t time; stamp = g_value_get_int64 (value); time = stamp; user_date = empathy_time_to_string_relative (time); text = g_strconcat ( _("<b>Location</b>, "), user_date, NULL); gtk_label_set_markup (GTK_LABEL (information->label_location), text); g_free (text); } /* Prepare the location information table */ if (information->table_location != NULL) { gtk_widget_destroy (information->table_location); } information->table_location = gtk_table_new (1, 2, FALSE); gtk_box_pack_start (GTK_BOX (information->subvbox_location), information->table_location, FALSE, FALSE, 5); g_hash_table_iter_init (&iter, location); while (g_hash_table_iter_next (&iter, &key, &pvalue)) { const gchar *skey; const gchar* user_label; GValue *gvalue; char *svalue = NULL; skey = (const gchar *) key; user_label = location_key_to_label (skey); gvalue = (GValue *) pvalue; label = gtk_label_new (user_label); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (information->table_location), label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0); gtk_widget_show (label); if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE) { gdouble dvalue; dvalue = g_value_get_double (gvalue); svalue = g_strdup_printf ("%f", dvalue); } else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING) { svalue = g_value_dup_string (gvalue); } else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64) { time_t time; time = g_value_get_int64 (value); svalue = empathy_time_to_string_utc (time, _("%B %e, %Y at %R UTC")); } if (svalue != NULL) { label = gtk_label_new (svalue); gtk_table_attach_defaults (GTK_TABLE (information->table_location), label, 1, 2, row, row + 1); gtk_misc_set_alignment (GTK_MISC (label), 0, 0); gtk_widget_show (label); } g_free (svalue); row++; } gtk_widget_show (information->table_location); #if HAVE_LIBCHAMPLAIN /* Cannot be displayed in tooltips until Clutter-Gtk can deal with such * windows */ if (has_position && !(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP)) { ClutterActor *marker; ChamplainLayer *layer; information->map_view_embed = gtk_champlain_embed_new (); information->map_view = gtk_champlain_embed_get_view ( GTK_CHAMPLAIN_EMBED (information->map_view_embed)); gtk_container_add (GTK_CONTAINER (information->viewport_map), information->map_view_embed); g_object_set (G_OBJECT (information->map_view), "show-license", FALSE, "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC, NULL); layer = champlain_layer_new (); champlain_view_add_layer (information->map_view, layer); marker = champlain_marker_new_with_text ( empathy_contact_get_name (information->contact), NULL, NULL, NULL); champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon); clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL); champlain_view_center_on (information->map_view, lat, lon); gtk_widget_show_all (information->viewport_map); } #endif gtk_widget_show (information->vbox_location); }