static void
__midgard_query_select_set_property (GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec)
{
MidgardQuerySelect *self = (MidgardQuerySelect *) (object);
GObject *mgd;
GObject *storage;
switch (property_id) {
case PROPERTY_CONNECTION:
if (!G_VALUE_HOLDS_OBJECT (value))
return;
MIDGARD_QUERY_EXECUTOR (self)->priv->mgd = g_value_dup_object (value);
/* In case of SQLite provider, use integer instead of boolean type,
* which is not supported in SQLite */
MidgardConfig *config = MIDGARD_QUERY_EXECUTOR (self)->priv->mgd->priv->config;
if (config->priv->dbtype == MIDGARD_DB_TYPE_SQLITE)
MIDGARD_QUERY_EXECUTOR (self)->priv->bool_is_int = TRUE;
break;
case PROPERTY_STORAGE:
if (!G_VALUE_HOLDS_OBJECT (value))
return;
MIDGARD_QUERY_EXECUTOR (self)->priv->storage = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec);
break;
}
}
gpointer
terminal_profile_get_property_object (TerminalProfile *profile,
const char *prop_name)
{
const GValue *value;
value = get_prop_value_from_prop_name (profile, prop_name);
g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_OBJECT (value), NULL);
if (!value || !G_VALUE_HOLDS_OBJECT (value))
return NULL;
return g_value_get_object (value);
}
static void
_midgard_workspace_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
MidgardWorkspace *self = MIDGARD_WORKSPACE (object);
switch (property_id) {
case PROPERTY_PARENT_WS:
if (!G_VALUE_HOLDS_OBJECT (value))
return;
GObject *obj = g_value_get_object (value);
if (!MIDGARD_IS_WORKSPACE (obj))
return;
MidgardWorkspace *parent_ws = g_value_dup_object (value);
self->priv->parent_ws = parent_ws;
self->priv->up_id = parent_ws->priv->id;
break;
case PROPERTY_NAME:
g_free (self->priv->name);
self->priv->name = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec);
break;
}
}
static void
gtk_radio_tool_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkRadioToolButton *button;
button = GTK_RADIO_TOOL_BUTTON (object);
switch (prop_id)
{
case PROP_GROUP:
{
GtkRadioToolButton *arg;
GSList *slist = NULL;
if (G_VALUE_HOLDS_OBJECT (value))
{
arg = GTK_RADIO_TOOL_BUTTON (g_value_get_object (value));
if (arg)
slist = gtk_radio_tool_button_get_group (arg);
gtk_radio_tool_button_set_group (button, slist);
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
__midgard_dbobject_set_property (GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec)
{
GObject *mgd;
switch (property_id) {
case PROPERTY_CONNECTION:
if (!G_VALUE_HOLDS_OBJECT (value))
return;
mgd = g_value_get_object (value);
if (!MIDGARD_IS_CONNECTION (mgd))
return;
MIDGARD_DBOBJECT (object)->dbpriv->mgd = MIDGARD_CONNECTION (mgd);
/* Add weak reference callback to connection.
* Instead of keeping connection's alive (implicitly) we create sentinel
* which guarantees connection's pointer to be null if connection is destroyed. */
g_object_weak_ref (mgd, __weak_ref_notify, object);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_radio_menu_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkRadioMenuItem *radio_menu_item;
radio_menu_item = GTK_RADIO_MENU_ITEM (object);
switch (prop_id)
{
GSList *slist;
case PROP_GROUP:
if (G_VALUE_HOLDS_OBJECT (value))
slist = gtk_radio_menu_item_get_group ((GtkRadioMenuItem*) g_value_get_object (value));
else
slist = NULL;
gtk_radio_menu_item_set_group (radio_menu_item, slist);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
exit
#endif
#include <glib-object.h>
#include <stdio.h>
int main (int argc, char **argv)
{
GValue *value;
/* initialize type system */
g_type_init();
/* allocate */
value = g_new0 (GValue, 1);
/* initialize GValue type to gint */
g_value_init (value, G_TYPE_INT);
g_value_set_int (value, 42);
g_print ("Value: %d\n", g_value_get_int (value));
if (G_VALUE_HOLDS_OBJECT (value))
{
g_print ("Container holds a GObject\n");
}
else
{
g_print ("Container does not hold a GObject\n");
}
g_free (value);
return 0;
}
gpointer
utils_value_ref_sink_object(const GValue* val)
{
if (val == NULL || !G_VALUE_HOLDS_OBJECT(val) || g_value_get_object(val) == NULL)
return NULL;
else
return g_object_ref_sink(g_value_get_object(val));
}
/**
* Get an object property
* @param filter_param A RSFilterParam
* @param name The name of the property
* @return The object if found, NULL otherwise
*/
gpointer
rs_filter_param_get_object(const RSFilterParam *filter_param, const gchar *name)
{
gpointer object = NULL;
GValue *val;
g_return_val_if_fail(RS_IS_FILTER_PARAM(filter_param), NULL);
g_return_val_if_fail(name != NULL, NULL);
g_return_val_if_fail(name[0] != '\0', NULL);
val = rs_filter_param_get_gvalue(filter_param, name);
if (val && G_VALUE_HOLDS_OBJECT(val))
object = g_value_dup_object(val);
return object;
}
gboolean
rb_signal_accumulator_object_handled (GSignalInvocationHint *hint,
GValue *return_accu,
const GValue *handler_return,
gpointer dummy)
{
if (handler_return == NULL ||
!G_VALUE_HOLDS_OBJECT (handler_return) ||
g_value_get_object (handler_return) == NULL)
return TRUE;
g_value_unset (return_accu);
g_value_init (return_accu, G_VALUE_TYPE (handler_return));
g_value_copy (handler_return, return_accu);
return FALSE;
}
static void
add_object_id(gpointer hkey,
gpointer hvalue,
gpointer user_data)
{
GValue *value = (GValue*)hvalue;
FileInfoData *filedata = (FileInfoData*)user_data;
const gchar *strkey;
gchar *end;
gint id;
strkey = g_quark_to_string(GPOINTER_TO_UINT(hkey));
if (!strkey || strkey[0] != '/' || !G_VALUE_HOLDS_OBJECT(value))
return;
if ((id = strtol(strkey + 1, &end, 10)) >= 0
&& gwy_strequal(end, "/data")
&& GWY_IS_DATA_FIELD(g_value_get_object(value))) {
filedata->nchannels++;
filedata->channels = g_slist_prepend(filedata->channels,
GINT_TO_POINTER(id));
return;
}
if (g_str_has_prefix(strkey, "/0/graph/graph/")
&& (id = strtol(strkey + 15, &end, 10)) >= 0
&& !*end
&& GWY_IS_GRAPH_MODEL(g_value_get_object(value))) {
filedata->ngraphs++;
filedata->graphs = g_slist_prepend(filedata->graphs,
GINT_TO_POINTER(id));
return;
}
if (g_str_has_prefix(strkey, "/sps/")
&& (id = strtol(strkey + 5, &end, 10)) >= 0
&& !*end
&& GWY_IS_SPECTRA(g_value_get_object(value))) {
filedata->nspectra++;
filedata->spectra = g_slist_prepend(filedata->spectra,
GINT_TO_POINTER(id));
return;
}
}
static void
__midgard_transaction_set_property (GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec)
{
GObject *mgd;
switch (property_id) {
case PROPERTY_CONNECTION:
/* Add new reference to MidgardConnection object */
if (!G_VALUE_HOLDS_OBJECT (value))
return;
MIDGARD_TRANSACTION (object)->priv->mgd = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
add_to_string (gpointer key, gpointer value, gpointer user_data)
{
const char *name = (const char *) key;
GString *buf = user_data;
GValue str_val = G_VALUE_INIT;
g_value_init (&str_val, G_TYPE_STRING);
if (!g_value_transform ((GValue *) value, &str_val)) {
if (G_VALUE_HOLDS_OBJECT (value)) {
GObject *obj = g_value_get_object (value);
if (obj) {
g_string_append_printf (buf, "{%s: %p (%s)}, ", name, obj,
G_OBJECT_TYPE_NAME (obj));
} else
g_string_append_printf (buf, "{%s: %p}, ", name, obj);
} else
g_string_append_printf (buf, "{%s: <transform error>}, ", name);
} else
g_string_append_printf (buf, "{%s: %s}, ", name, g_value_get_string (&str_val));
g_value_unset (&str_val);
}
static void
add_to_string (gpointer key, gpointer value, gpointer user_data)
{
char *buf = (char *) user_data;
GValue str_val = { 0, };
g_value_init (&str_val, G_TYPE_STRING);
if (!g_value_transform ((GValue *) value, &str_val)) {
if (G_VALUE_HOLDS_OBJECT (value)) {
GObject *obj = g_value_get_object (value);
if (g_value_get_object (value)) {
sprintf (buf + strlen (buf), "{%s: %p (%s)}, ",
(const char *) key, obj, G_OBJECT_TYPE_NAME (obj));
} else {
sprintf (buf + strlen (buf), "{%s: %p}, ", (const char *) key, obj);
}
} else
sprintf (buf + strlen (buf), "{%s: <transform error>}, ", (const char *) key);
} else {
sprintf (buf + strlen (buf), "{%s: %s}, ", (const char *) key, g_value_get_string (&str_val));
}
g_value_unset (&str_val);
}
static void
add_channel_id(gpointer hkey,
gpointer hvalue,
gpointer user_data)
{
GValue *value = (GValue*)hvalue;
GSList **list = (GSList**)user_data;
const gchar *strkey;
gchar *end;
gint id;
strkey = g_quark_to_string(GPOINTER_TO_UINT(hkey));
if (!strkey)
return;
if (strkey[0] != '/'
|| (id = strtol(strkey + 1, &end, 10)) < 0
|| !gwy_strequal(end, "/data")
|| !G_VALUE_HOLDS_OBJECT(value)
|| !GWY_IS_DATA_FIELD(g_value_get_object(value)))
return;
*list = g_slist_prepend(*list, GINT_TO_POINTER(id));
}
JNIEXPORT jlong JNICALL
Java_org_gnome_glib_GValue_g_1value_1get_1object
(
JNIEnv* env,
jclass cls,
jlong _value
)
{
GValue* value;
GObject* object;
// translate value
value = (GValue*) _value;
if (!G_VALUE_HOLDS_OBJECT(value)) {
bindings_java_throw(env, "You've asked for the GObject within a GValue, but it's not a G_TYPE_OBJECT!");
return 0L;
}
// call function
object = g_value_get_object(value);
// and return
return (jlong) object;
}
gboolean object_in_gvalue(GValue* v) {
return G_VALUE_HOLDS_OBJECT(v);
}
/**
* gimp_config_deserialize_property:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function deserializes a single property of @config. You
* shouldn't need to call this function directly. If possible, use
* gimp_config_deserialize_properties() instead.
*
* Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
* expected #GTokenType or %G_TOKEN_NONE if the expected token was
* found but couldn't be parsed.
*
* Since: GIMP 2.4
**/
GTokenType
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *config_iface = NULL;
GimpConfigInterface *parent_iface = NULL;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
GValue value = { 0, };
guint old_scope_id;
old_scope_id = g_scanner_set_scope (scanner, 0);
prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
g_value_init (&value, prop_spec->value_type);
if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
{
GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
*
* Therefore, we ask param_spec->owner_type's immediate parent class
* for it's GimpConfigInterface and check if we get a different
* pointer.
*
* (if the pointers are the same, param_spec->owner_type's
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class);
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG);
}
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
else
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
g_scanner_peek_next_token (scanner) == token)
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("%s: couldn't deserialize property %s::%s of type %s",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
#endif
g_value_unset (&value);
g_scanner_set_scope (scanner, old_scope_id);
return token;
}
gint64
gimp_g_value_get_memsize (GValue *value)
{
gint64 memsize = 0;
if (! value)
return 0;
if (G_VALUE_HOLDS_STRING (value))
{
memsize += gimp_string_get_memsize (g_value_get_string (value));
}
else if (G_VALUE_HOLDS_BOXED (value))
{
if (GIMP_VALUE_HOLDS_RGB (value))
{
memsize += sizeof (GimpRGB);
}
else if (GIMP_VALUE_HOLDS_MATRIX2 (value))
{
memsize += sizeof (GimpMatrix2);
}
else if (GIMP_VALUE_HOLDS_PARASITE (value))
{
memsize += gimp_parasite_get_memsize (g_value_get_boxed (value),
NULL);
}
else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT8_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT16_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
{
GimpArray *array = g_value_get_boxed (value);
if (array)
memsize += (sizeof (GimpArray) +
array->static_data ? 0 : array->length);
}
else if (GIMP_VALUE_HOLDS_STRING_ARRAY (value))
{
GimpArray *array = g_value_get_boxed (value);
if (array)
{
memsize += sizeof (GimpArray);
if (! array->static_data)
{
gchar **tmp = (gchar **) array->data;
gint i;
memsize += array->length * sizeof (gchar *);
for (i = 0; i < array->length; i++)
memsize += gimp_string_get_memsize (tmp[i]);
}
}
}
else
{
g_printerr ("%s: unhandled boxed value type: %s\n",
G_STRFUNC, G_VALUE_TYPE_NAME (value));
}
}
else if (G_VALUE_HOLDS_OBJECT (value))
{
g_printerr ("%s: unhandled object value type: %s\n",
G_STRFUNC, G_VALUE_TYPE_NAME (value));
}
return memsize + sizeof (GValue);
}
/**
* g_strdup_value_contents:
* @value: #GValue which contents are to be described.
*
* Return a newly allocated string, which describes the contents of a
* #GValue. The main purpose of this function is to describe #GValue
* contents for debugging output, the way in which the contents are
* described may change between different GLib versions.
*
* Returns: Newly allocated string.
*/
gchar*
g_strdup_value_contents (const GValue *value)
{
const gchar *src;
gchar *contents;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
if (G_VALUE_HOLDS_STRING (value))
{
src = g_value_get_string (value);
if (!src)
contents = g_strdup ("NULL");
else
{
gchar *s = g_strescape (src, NULL);
contents = g_strdup_printf ("\"%s\"", s);
g_free (s);
}
}
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
{
GValue tmp_value = { 0, };
gchar *s;
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_transform (value, &tmp_value);
s = g_strescape (g_value_get_string (&tmp_value), NULL);
g_value_unset (&tmp_value);
if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
contents = g_strdup_printf ("((%s) %s)",
g_type_name (G_VALUE_TYPE (value)),
s);
else
contents = g_strdup (s ? s : "NULL");
g_free (s);
}
else if (g_value_fits_pointer (value))
{
gpointer p = g_value_peek_pointer (value);
if (!p)
contents = g_strdup ("NULL");
else if (G_VALUE_HOLDS_OBJECT (value))
contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS_PARAM (value))
contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
GStrv strv = g_value_get_boxed (value);
GString *tmp = g_string_new ("[");
while (*strv != NULL)
{
gchar *escaped = g_strescape (*strv, NULL);
g_string_append_printf (tmp, "\"%s\"", escaped);
g_free (escaped);
if (*++strv != NULL)
g_string_append (tmp, ", ");
}
g_string_append (tmp, "]");
contents = g_string_free (tmp, FALSE);
}
else if (G_VALUE_HOLDS_BOXED (value))
contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
else if (G_VALUE_HOLDS_POINTER (value))
contents = g_strdup_printf ("((gpointer) %p)", p);
else
contents = g_strdup ("???");
}
else
contents = g_strdup ("???");
return contents;
}
