mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2025-08-01 15:03:39 +02:00
changed prototype of g_boxed_type_register_static() to contain an optional
Wed Mar 7 09:36:33 2001 Tim Janik <timj@gtk.org> * gboxed.[hc]: changed prototype of g_boxed_type_register_static() to contain an optional init function and a hint at whether the boxed structure uses ref counting internally. added g_value_set_boxed_take_ownership(). made G_TYPE_BOXED an abstract value type. * genums.[hc]: made G_TYPE_ENUM and G_TYPE_FLAGS abstract value types. * glib-genmarshal.c: argument type changes, preparation for third-party arg specification. * gobject.[hc]: cleaned up get/set property code. added g_strdup_value_contents() to improve warnings. * gparam.[hc]: added g_param_value_convert(), taking over responsibility of the old g_value_convert(). added G_PARAM_LAX_VALIDATION flag so validation alterations may be valid a part of the property setting process. * gparamspecs.[hc]: made value comparisons stable (for sort applications). added GParamSpecValueArray, a param spec for value arrays and GParamSpecClosure. nuked the value exchange functions and GParamSpecCCallback. * gtype.[hc]: catch unintialized usages of the type system with g_return_val_if_uninitialized(). introduced G_TYPE_FLAG_VALUE_ABSTRACT to flag types that introduce a value table, but can't be used for g_value_init(). cleaned up reserved type ids. * gvalue.[hc]: code cleanups and saner checking. nuked the value exchange API. implemented value transformations, we can't really "convert" values, rather transforms are an anylogy to C casts, real conversions need a param spec for validation, which is why g_param_value_convert() does real conversions now. * gvaluearray.[hc]: new files that implement a GValueArray, a struct that can hold inhomogeneous arrays of value (to that extend that it also allowes undefined values, i.e. G_VALUE_TYPE(value)==0). this is exposed to the type system as a boxed type. * gvaluetransform.c: new file implementing most of the former value exchange functions as single-sided transformations. * gvaluetypes.[hc]: nuked G_TYPE_CCALLBACK, added g_value_set_string_take_ownership(). * *.h: s/G_IS_VALUE_/G_VALUE_HOLDS_/. * *.[hc]: many fixes and cleanups. * many warning improvements. Tue Feb 27 18:35:15 2001 Tim Janik <timj@gtk.org> * gobject.c (g_object_get_valist): urg, pass G_VALUE_NOCOPY_CONTENTS into G_VALUE_LCOPY(), this needs proper documenting. * gparam.c: fixed G_PARAM_USER_MASK. * gtype.c (type_data_make_W): (type_data_last_unref_Wm): fixed invalid memory freeing. * gobject.c (g_object_last_unref): destroy signal handlers associated with object, right before finalization. * gsignal.c (g_signal_parse_name): catch destroyed nodes or signals that don't actually support details. * gobject.[hc]: got rid of property trailers. nuked GObject properties "data" and the "signal" variants. (g_object_connect): new convenience function to do multiple signal connections at once. (g_object_disconnect): likewise, for disconnections. * gparam.[hc] (g_param_spec_pool_lookup): took out trailer support. * gvalue.[hc]: marked g_value_fits_pointer() and g_value_peek_pointer() as private (the latter got renamed from g_value_get_as_pointer()). Wed Mar 7 09:32:06 2001 Tim Janik <timj@gtk.org> * glib-object.h: add gvaluearray.h. * gstring.[hc]: fixup naming of g_string_sprint*. * gtypes.h: fixed GCompareDataFunc naming. Wed Mar 7 09:33:27 2001 Tim Janik <timj@gtk.org> * gobject/Makefile.am: shuffled rules to avoid excessive rebuilds. * gobject/gobject-sections.txt: updates. * gobject/tmpl/*: bunch of updates, added another patch from Eric Lemings <eric.b.lemings@lmco.com>.
This commit is contained in:
Tim Janik
Tim Janik
442
gobject/gvalue.c
442
gobject/gvalue.c
@@ -1,5 +1,5 @@
|
||||
/* GObject - GLib Type, Object, Parameter and Signal Library
|
||||
* Copyright (C) 1997, 1998, 1999, 2000 Tim Janik and Red Hat, Inc.
|
||||
* Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@@ -25,66 +25,130 @@
|
||||
|
||||
#include "gvalue.h"
|
||||
#include "gvaluecollector.h"
|
||||
#include "gbsearcharray.h"
|
||||
|
||||
|
||||
/* --- typedefs & structures --- */
|
||||
typedef struct
|
||||
{
|
||||
GType value_type1;
|
||||
GType value_type2;
|
||||
GValueExchange func;
|
||||
GType first_type;
|
||||
} ExchangeEntry;
|
||||
typedef struct {
|
||||
GType src_type;
|
||||
GType dest_type;
|
||||
GValueTransform func;
|
||||
} TransformEntry;
|
||||
|
||||
|
||||
/* --- prototypes --- */
|
||||
static gint transform_entries_cmp (gconstpointer bsearch_node1,
|
||||
gconstpointer bsearch_node2);
|
||||
|
||||
|
||||
/* --- variables --- */
|
||||
static GHashTable *param_exchange_ht = NULL;
|
||||
static GBSearchArray transform_array = {
|
||||
transform_entries_cmp,
|
||||
sizeof (TransformEntry),
|
||||
0, /* no flags */
|
||||
0, NULL,
|
||||
};
|
||||
|
||||
|
||||
/* --- functions --- */
|
||||
void
|
||||
static inline void /* keep this function in sync with gvaluecollector.h and gboxed.c */
|
||||
value_meminit (GValue *value,
|
||||
GType value_type)
|
||||
{
|
||||
value->g_type = value_type;
|
||||
memset (value->data, 0, sizeof (value->data));
|
||||
}
|
||||
|
||||
GValue*
|
||||
g_value_init (GValue *value,
|
||||
GType g_type)
|
||||
{
|
||||
GTypeValueTable *value_table = g_type_value_table_peek (g_type);
|
||||
|
||||
g_return_if_fail (value != NULL);
|
||||
g_return_if_fail (G_VALUE_TYPE (value) == 0);
|
||||
|
||||
if (value_table)
|
||||
/* g_return_val_if_fail (G_TYPE_IS_VALUE (g_type), NULL); be more elaborate below */
|
||||
g_return_val_if_fail (value != NULL, NULL);
|
||||
/* g_return_val_if_fail (G_VALUE_TYPE (value) == 0, NULL); be more elaborate below */
|
||||
|
||||
if (G_TYPE_IS_VALUE (g_type) && G_VALUE_TYPE (value) == 0)
|
||||
{
|
||||
memset (value, 0, sizeof (*value));
|
||||
value->g_type = g_type;
|
||||
GTypeValueTable *value_table = g_type_value_table_peek (g_type);
|
||||
|
||||
/* setup and init */
|
||||
value_meminit (value, g_type);
|
||||
value_table->value_init (value);
|
||||
}
|
||||
else
|
||||
g_warning (G_STRLOC ": cannot initialize value of type `%s' which has no GTypeValueTable",
|
||||
g_type_name (g_type));
|
||||
else if (G_VALUE_TYPE (value))
|
||||
g_warning ("%s: cannot initialize GValue with type `%s', the value has already been initialized as `%s'",
|
||||
G_STRLOC,
|
||||
g_type_name (g_type),
|
||||
g_type_name (G_VALUE_TYPE (value)));
|
||||
else /* !G_TYPE_IS_VALUE (g_type) */
|
||||
g_warning ("%s: cannot initialize GValue with type `%s', %s",
|
||||
G_STRLOC,
|
||||
g_type_name (g_type),
|
||||
g_type_value_table_peek (g_type) ?
|
||||
"this type is abstract with regards to GValue use, use a more specific (derived) type" :
|
||||
"this type has no GTypeValueTable implementation");
|
||||
return value;
|
||||
}
|
||||
|
||||
void
|
||||
g_value_copy (const GValue *src_value,
|
||||
GValue *dest_value)
|
||||
{
|
||||
GTypeValueTable *value_table;
|
||||
|
||||
g_return_if_fail (G_IS_VALUE (src_value));
|
||||
g_return_if_fail (G_IS_VALUE (dest_value));
|
||||
g_return_if_fail (g_type_is_a (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)));
|
||||
|
||||
value_table = g_type_value_table_peek (G_VALUE_TYPE (dest_value));
|
||||
if (!value_table)
|
||||
g_return_if_fail (g_type_value_table_peek (G_VALUE_TYPE (dest_value)) != NULL);
|
||||
g_return_if_fail (g_value_type_compatible (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value)));
|
||||
|
||||
if (src_value != dest_value)
|
||||
{
|
||||
/* make sure dest_value's value is free()d and zero initialized */
|
||||
g_value_reset (dest_value);
|
||||
|
||||
GType dest_type = G_VALUE_TYPE (dest_value);
|
||||
GTypeValueTable *value_table = g_type_value_table_peek (dest_type);
|
||||
|
||||
/* make sure dest_value's value is free()d */
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (dest_value);
|
||||
|
||||
/* setup and copy */
|
||||
value_meminit (dest_value, dest_type);
|
||||
value_table->value_copy (src_value, dest_value);
|
||||
}
|
||||
}
|
||||
|
||||
GValue*
|
||||
g_value_reset (GValue *value)
|
||||
{
|
||||
GTypeValueTable *value_table;
|
||||
GType g_type;
|
||||
|
||||
g_return_val_if_fail (G_IS_VALUE (value), NULL);
|
||||
|
||||
g_type = G_VALUE_TYPE (value);
|
||||
value_table = g_type_value_table_peek (g_type);
|
||||
|
||||
/* make sure value's value is free()d */
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (value);
|
||||
|
||||
/* setup and init */
|
||||
value_meminit (value, g_type);
|
||||
value_table->value_init (value);
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
void
|
||||
g_value_unset (GValue *value)
|
||||
{
|
||||
GTypeValueTable *value_table;
|
||||
|
||||
g_return_if_fail (G_IS_VALUE (value));
|
||||
|
||||
value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
|
||||
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (value);
|
||||
memset (value, 0, sizeof (*value));
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_value_fits_pointer (const GValue *value)
|
||||
{
|
||||
@@ -93,22 +157,18 @@ g_value_fits_pointer (const GValue *value)
|
||||
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
|
||||
|
||||
value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
|
||||
if (!value_table)
|
||||
g_return_val_if_fail (g_type_value_table_peek (G_VALUE_TYPE (value)) != NULL, FALSE);
|
||||
|
||||
return value_table->value_peek_pointer != NULL;
|
||||
}
|
||||
|
||||
gpointer
|
||||
g_value_get_as_pointer (const GValue *value)
|
||||
g_value_peek_pointer (const GValue *value)
|
||||
{
|
||||
GTypeValueTable *value_table;
|
||||
|
||||
g_return_val_if_fail (G_IS_VALUE (value), NULL);
|
||||
|
||||
value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
|
||||
if (!value_table)
|
||||
g_return_val_if_fail (g_type_value_table_peek (G_VALUE_TYPE (value)) != NULL, NULL);
|
||||
if (!value_table->value_peek_pointer)
|
||||
g_return_val_if_fail (g_value_fits_pointer (value) == TRUE, NULL);
|
||||
|
||||
@@ -119,231 +179,167 @@ void
|
||||
g_value_set_instance (GValue *value,
|
||||
gpointer instance)
|
||||
{
|
||||
g_return_if_fail (G_IS_VALUE (value));
|
||||
GType g_type;
|
||||
GTypeValueTable *value_table;
|
||||
GTypeCValue cvalue;
|
||||
gchar *error_msg;
|
||||
|
||||
g_value_reset (value);
|
||||
g_return_if_fail (G_IS_VALUE (value));
|
||||
if (instance)
|
||||
{
|
||||
GType g_type = G_VALUE_TYPE (value);
|
||||
GTypeValueTable *value_table = g_type_value_table_peek (g_type);
|
||||
GTypeCValue cvalue = { 0, };
|
||||
gchar *error_msg;
|
||||
|
||||
g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
|
||||
g_return_if_fail (g_type_is_a (G_TYPE_FROM_INSTANCE (instance), G_VALUE_TYPE (value)));
|
||||
g_return_if_fail (strcmp (value_table->collect_format, "p") == 0);
|
||||
g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (instance), G_VALUE_TYPE (value)));
|
||||
}
|
||||
|
||||
g_type = G_VALUE_TYPE (value);
|
||||
value_table = g_type_value_table_peek (g_type);
|
||||
|
||||
g_return_if_fail (strcmp (value_table->collect_format, "p") == 0);
|
||||
|
||||
memset (&cvalue, 0, sizeof (cvalue));
|
||||
cvalue.v_pointer = instance;
|
||||
|
||||
/* make sure value's value is free()d */
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (value);
|
||||
|
||||
/* setup and collect */
|
||||
value_meminit (value, g_type);
|
||||
error_msg = value_table->collect_value (value, 1, &cvalue, 0);
|
||||
if (error_msg)
|
||||
{
|
||||
g_warning ("%s: %s", G_STRLOC, error_msg);
|
||||
g_free (error_msg);
|
||||
|
||||
cvalue.v_pointer = instance;
|
||||
error_msg = value_table->collect_value (value, 1, &cvalue, 0);
|
||||
|
||||
if (error_msg)
|
||||
{
|
||||
g_warning ("%s: %s", G_STRLOC, error_msg);
|
||||
g_free (error_msg);
|
||||
|
||||
/* we purposely leak the value here, it might not be
|
||||
* in a sane state if an error condition occoured
|
||||
*/
|
||||
memset (value, 0, sizeof (*value));
|
||||
value->g_type = g_type;
|
||||
value_table->value_init (value);
|
||||
}
|
||||
/* we purposely leak the value here, it might not be
|
||||
* in a sane state if an error condition occoured
|
||||
*/
|
||||
value_meminit (value, g_type);
|
||||
value_table->value_init (value);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
g_value_unset (GValue *value)
|
||||
static GValueTransform
|
||||
transform_func_lookup (GType src_type,
|
||||
GType dest_type)
|
||||
{
|
||||
GTypeValueTable *value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
|
||||
|
||||
g_return_if_fail (G_IS_VALUE (value));
|
||||
if (!value_table)
|
||||
g_return_if_fail (g_type_value_table_peek (G_VALUE_TYPE (value)) != NULL);
|
||||
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (value);
|
||||
memset (value, 0, sizeof (*value));
|
||||
}
|
||||
TransformEntry entry;
|
||||
|
||||
void
|
||||
g_value_reset (GValue *value)
|
||||
{
|
||||
GTypeValueTable *value_table;
|
||||
GType g_type;
|
||||
|
||||
g_return_if_fail (G_IS_VALUE (value));
|
||||
|
||||
value_table = g_type_value_table_peek (G_VALUE_TYPE (value));
|
||||
g_type = G_VALUE_TYPE (value);
|
||||
|
||||
if (value_table->value_free)
|
||||
value_table->value_free (value);
|
||||
memset (value, 0, sizeof (*value));
|
||||
|
||||
value->g_type = g_type;
|
||||
value_table->value_init (value);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
exchange_entries_equal (gconstpointer v1,
|
||||
gconstpointer v2)
|
||||
{
|
||||
const ExchangeEntry *entry1 = v1;
|
||||
const ExchangeEntry *entry2 = v2;
|
||||
|
||||
return (entry1->value_type1 == entry2->value_type1 &&
|
||||
entry1->value_type2 == entry2->value_type2);
|
||||
}
|
||||
|
||||
static guint
|
||||
exchange_entry_hash (gconstpointer key)
|
||||
{
|
||||
const ExchangeEntry *entry = key;
|
||||
|
||||
return entry->value_type1 ^ entry->value_type2;
|
||||
}
|
||||
|
||||
static void
|
||||
value_exchange_memcpy (GValue *value1,
|
||||
GValue *value2)
|
||||
{
|
||||
GValue tmp_value;
|
||||
|
||||
memcpy (&tmp_value.data, &value1->data, sizeof (value1->data));
|
||||
memcpy (&value1->data, &value2->data, sizeof (value1->data));
|
||||
memcpy (&value2->data, &tmp_value.data, sizeof (value2->data));
|
||||
}
|
||||
|
||||
static inline GValueExchange
|
||||
exchange_func_lookup (GType value_type1,
|
||||
GType value_type2,
|
||||
gboolean *need_swap)
|
||||
{
|
||||
if (value_type1 == value_type2)
|
||||
return value_exchange_memcpy;
|
||||
else
|
||||
entry.src_type = src_type;
|
||||
do
|
||||
{
|
||||
GType type1 = value_type1;
|
||||
|
||||
entry.dest_type = dest_type;
|
||||
do
|
||||
{
|
||||
GType type2 = value_type2;
|
||||
TransformEntry *e;
|
||||
|
||||
do
|
||||
e = g_bsearch_array_lookup (&transform_array, &entry);
|
||||
if (e)
|
||||
{
|
||||
ExchangeEntry entry, *ret;
|
||||
|
||||
entry.value_type1 = MIN (type1, type2);
|
||||
entry.value_type2 = MAX (type1, type2);
|
||||
ret = g_hash_table_lookup (param_exchange_ht, &entry);
|
||||
if (ret)
|
||||
{
|
||||
if (need_swap)
|
||||
*need_swap = ret->first_type == type2;
|
||||
|
||||
return ret->func;
|
||||
}
|
||||
|
||||
type2 = g_type_parent (type2);
|
||||
/* need to check that there hasn't been a change in value handling */
|
||||
if (g_type_value_table_peek (entry.dest_type) == g_type_value_table_peek (dest_type) &&
|
||||
g_type_value_table_peek (entry.src_type) == g_type_value_table_peek (src_type))
|
||||
return e->func;
|
||||
}
|
||||
while (type2);
|
||||
|
||||
type1 = g_type_parent (type1);
|
||||
entry.dest_type = g_type_parent (entry.dest_type);
|
||||
}
|
||||
while (type1);
|
||||
while (entry.dest_type);
|
||||
|
||||
entry.src_type = g_type_parent (entry.src_type);
|
||||
}
|
||||
|
||||
while (entry.src_type);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
g_value_register_exchange_func (GType value_type1,
|
||||
GType value_type2,
|
||||
GValueExchange func)
|
||||
static gint
|
||||
transform_entries_cmp (gconstpointer bsearch_node1,
|
||||
gconstpointer bsearch_node2)
|
||||
{
|
||||
ExchangeEntry entry;
|
||||
|
||||
g_return_if_fail (g_type_name (value_type1) != NULL);
|
||||
g_return_if_fail (g_type_name (value_type2) != NULL);
|
||||
g_return_if_fail (func != NULL);
|
||||
|
||||
entry.value_type1 = MIN (value_type1, value_type2);
|
||||
entry.value_type2 = MAX (value_type1, value_type2);
|
||||
if (param_exchange_ht && g_hash_table_lookup (param_exchange_ht, &entry))
|
||||
g_warning (G_STRLOC ": cannot re-register param value exchange function "
|
||||
"for `%s' and `%s'",
|
||||
g_type_name (value_type1),
|
||||
g_type_name (value_type2));
|
||||
const TransformEntry *e1 = bsearch_node1;
|
||||
const TransformEntry *e2 = bsearch_node2;
|
||||
gint cmp = G_BSEARCH_ARRAY_CMP (e1->src_type, e2->src_type);
|
||||
|
||||
if (cmp)
|
||||
return cmp;
|
||||
else
|
||||
{
|
||||
ExchangeEntry *entry = g_new (ExchangeEntry, 1);
|
||||
|
||||
if (!param_exchange_ht)
|
||||
param_exchange_ht = g_hash_table_new (exchange_entry_hash, exchange_entries_equal);
|
||||
entry->value_type1 = MIN (value_type1, value_type2);
|
||||
entry->value_type2 = MAX (value_type1, value_type2);
|
||||
entry->func = func;
|
||||
entry->first_type = value_type1;
|
||||
g_hash_table_insert (param_exchange_ht, entry, entry);
|
||||
}
|
||||
return G_BSEARCH_ARRAY_CMP (e1->dest_type, e2->dest_type);
|
||||
}
|
||||
|
||||
void
|
||||
g_value_register_transform_func (GType src_type,
|
||||
GType dest_type,
|
||||
GValueTransform transform_func)
|
||||
{
|
||||
TransformEntry entry;
|
||||
|
||||
g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (src_type));
|
||||
g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (dest_type));
|
||||
g_return_if_fail (transform_func != NULL);
|
||||
|
||||
if (transform_func_lookup (src_type, dest_type))
|
||||
g_warning ("reregistering value transformation function (%p) for `%s' to `%s'",
|
||||
transform_func,
|
||||
g_type_name (src_type),
|
||||
g_type_name (dest_type));
|
||||
entry.src_type = src_type;
|
||||
entry.dest_type = dest_type;
|
||||
entry.func = transform_func;
|
||||
g_bsearch_array_insert (&transform_array, &entry, TRUE);
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_value_types_exchangable (GType value_type1,
|
||||
GType value_type2)
|
||||
g_value_type_transformable (GType src_type,
|
||||
GType dest_type)
|
||||
{
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (value_type1), FALSE); /* these might bite us, think G_TYPE_ENUM */
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (value_type2), FALSE);
|
||||
|
||||
return exchange_func_lookup (value_type1, value_type2, NULL) != NULL;
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
|
||||
|
||||
return (g_value_type_compatible (src_type, dest_type) ||
|
||||
transform_func_lookup (src_type, dest_type) != NULL);
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_values_exchange (GValue *value1,
|
||||
GValue *value2)
|
||||
g_value_type_compatible (GType src_type,
|
||||
GType dest_type)
|
||||
{
|
||||
g_return_val_if_fail (G_IS_VALUE (value1), FALSE);
|
||||
g_return_val_if_fail (G_IS_VALUE (value2), FALSE);
|
||||
|
||||
if (value1 != value2)
|
||||
{
|
||||
gboolean need_swap;
|
||||
GValueExchange value_exchange = exchange_func_lookup (G_VALUE_TYPE (value1),
|
||||
G_VALUE_TYPE (value2),
|
||||
&need_swap);
|
||||
if (value_exchange)
|
||||
{
|
||||
if (need_swap)
|
||||
value_exchange (value2, value1);
|
||||
else
|
||||
value_exchange (value1, value2);
|
||||
}
|
||||
|
||||
return value_exchange != NULL;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (src_type), FALSE);
|
||||
g_return_val_if_fail (G_TYPE_IS_VALUE (dest_type), FALSE);
|
||||
|
||||
return (g_type_is_a (src_type, dest_type) &&
|
||||
g_type_value_table_peek (dest_type) == g_type_value_table_peek (src_type));
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_value_convert (const GValue *src_value,
|
||||
GValue *dest_value)
|
||||
g_value_transform (const GValue *src_value,
|
||||
GValue *dest_value)
|
||||
{
|
||||
gboolean success = TRUE;
|
||||
|
||||
GType dest_type;
|
||||
|
||||
g_return_val_if_fail (G_IS_VALUE (src_value), FALSE);
|
||||
g_return_val_if_fail (G_IS_VALUE (dest_value), FALSE);
|
||||
|
||||
if (src_value != dest_value)
|
||||
|
||||
dest_type = G_VALUE_TYPE (dest_value);
|
||||
if (g_value_type_compatible (G_VALUE_TYPE (src_value), dest_type))
|
||||
{
|
||||
GValue tmp_value = { 0, };
|
||||
g_value_copy (src_value, dest_value);
|
||||
|
||||
g_value_init (&tmp_value, G_VALUE_TYPE (src_value));
|
||||
g_value_copy (src_value, &tmp_value);
|
||||
|
||||
success = g_values_exchange (&tmp_value, dest_value);
|
||||
g_value_unset (&tmp_value);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return success;
|
||||
else
|
||||
{
|
||||
GValueTransform transform = transform_func_lookup (G_VALUE_TYPE (src_value), dest_type);
|
||||
|
||||
if (transform)
|
||||
{
|
||||
g_value_unset (dest_value);
|
||||
|
||||
/* setup and transform */
|
||||
value_meminit (dest_value, dest_type);
|
||||
transform (src_value, dest_value);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user