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