static void
gog_object_write_property_sax (GogObject const *obj, GParamSpec *pspec, GsfXMLOut *output)
{
GObject *val_obj;
GType prop_type = G_PARAM_SPEC_VALUE_TYPE (pspec);
GValue value = { 0 };
g_value_init (&value, prop_type);
g_object_get_property (G_OBJECT (obj), pspec->name, &value);
/* No need to save default values */
if (((pspec->flags & GOG_PARAM_POSITION) &&
gog_object_is_default_position_flags (obj, pspec->name)) ||
(!(pspec->flags & GOG_PARAM_FORCE_SAVE) &&
!(pspec->flags & GOG_PARAM_POSITION) &&
g_param_value_defaults (pspec, &value))) {
g_value_unset (&value);
return;
}
switch (G_TYPE_FUNDAMENTAL (prop_type)) {
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
case G_TYPE_BOOLEAN:
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_ENUM:
case G_TYPE_FLAGS: {
GValue str = { 0 };
g_value_init (&str, G_TYPE_STRING);
g_value_transform (&value, &str);
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, g_value_get_string (&str));
gsf_xml_out_end_element (output); /* </property> */
g_value_unset (&str);
break;
}
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
GValue vd = { 0 };
GString *str = g_string_new (NULL);
g_value_init (&vd, G_TYPE_DOUBLE);
g_value_transform (&value, &vd);
go_dtoa (str, "!g", g_value_get_double (&vd));
g_value_unset (&vd);
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, str->str);
gsf_xml_out_end_element (output); /* </property> */
g_string_free (str, TRUE);
break;
}
case G_TYPE_STRING: {
char const *str = g_value_get_string (&value);
if (str != NULL) {
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, str);
gsf_xml_out_end_element (output); /* </property> */
}
break;
}
case G_TYPE_OBJECT:
val_obj = g_value_get_object (&value);
if (val_obj != NULL) {
if (GO_IS_PERSIST (val_obj)) {
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
go_persist_sax_save (GO_PERSIST (val_obj), output);
gsf_xml_out_end_element (output); /* </property> */
} else
g_warning ("How are we supposed to persist this ??");
}
break;
default:
g_warning ("I could not persist property \"%s\", since type \"%s\" is unhandled.",
g_param_spec_get_name (pspec), g_type_name (G_TYPE_FUNDAMENTAL(prop_type)));
}
g_value_unset (&value);
}
static void
check_property (const char *output,
GParamSpec *pspec,
GValue *value)
{
GValue default_value = G_VALUE_INIT;
char *v, *dv, *msg;
if (g_param_value_defaults (pspec, value))
return;
g_value_init (&default_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_param_value_set_default (pspec, &default_value);
v = g_strdup_value_contents (value);
dv = g_strdup_value_contents (&default_value);
msg = g_strdup_printf ("%s %s.%s: %s != %s\n",
output,
g_type_name (pspec->owner_type),
pspec->name,
dv, v);
g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__,
G_STRFUNC, msg);
g_free (msg);
g_free (v);
g_free (dv);
g_value_unset (&default_value);
}
static void
test_defaults (GType type, const char *name)
{
GParamSpec **property_specs;
guint n_property_specs;
GObject *setting;
int i;
setting = g_object_new (type, NULL);
property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (setting), &n_property_specs);
ASSERT (property_specs != NULL,
name, "couldn't find property specs for object of type '%s'",
g_type_name (G_OBJECT_TYPE (setting)));
for (i = 0; i < n_property_specs; i++) {
GParamSpec *prop_spec = property_specs[i];
GValue value = G_VALUE_INIT;
GValue defvalue = G_VALUE_INIT;
char *actual, *expected;
gboolean ok = FALSE;
/* Ignore non-fundamental types since they won't really have
* defaults.
*/
if (!G_TYPE_IS_FUNDAMENTAL (prop_spec->value_type))
continue;
g_value_init (&value, prop_spec->value_type);
g_object_get_property (G_OBJECT (setting), prop_spec->name, &value);
g_value_init (&defvalue, prop_spec->value_type);
g_param_value_set_default (prop_spec, &defvalue);
actual = g_strdup_value_contents (&value);
expected = g_strdup_value_contents (&defvalue);
if (!strcmp (prop_spec->name, NM_SETTING_NAME)) {
/* 'name' is always the setting name, not the default value */
ok = !strcmp (nm_setting_get_name (NM_SETTING (setting)), name);
g_free (expected);
expected = g_strdup (name);
} else
ok = g_param_value_defaults (prop_spec, &value);
ASSERT (ok,
name, "property '%s' value '%s' not the expected default value '%s'",
prop_spec->name, actual, expected);
g_free (actual);
g_free (expected);
g_value_unset (&value);
g_value_unset (&defvalue);
}
g_free (property_specs);
g_object_unref (setting);
}
/**
* nm_setting_to_hash:
* @setting: the #NMSetting
* @flags: hash flags, e.g. %NM_SETTING_HASH_FLAG_ALL
*
* Converts the #NMSetting into a #GHashTable mapping each setting property
* name to a GValue describing that property, suitable for marshalling over
* D-Bus or serializing. The mapping is string to GValue.
*
* Returns: (transfer full) (element-type utf8 GObject.Value): a new #GHashTable
* describing the setting's properties
**/
GHashTable *
nm_setting_to_hash (NMSetting *setting, NMSettingHashFlags flags)
{
GHashTable *hash;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
g_return_val_if_fail (setting != NULL, NULL);
g_return_val_if_fail (NM_IS_SETTING (setting), NULL);
property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (setting), &n_property_specs);
if (!property_specs) {
g_warning ("%s: couldn't find property specs for object of type '%s'",
__func__, g_type_name (G_OBJECT_TYPE (setting)));
return NULL;
}
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free, destroy_gvalue);
for (i = 0; i < n_property_specs; i++) {
GParamSpec *prop_spec = property_specs[i];
GValue *value;
if (!(prop_spec->flags & NM_SETTING_PARAM_SERIALIZE))
continue;
if ( (flags & NM_SETTING_HASH_FLAG_NO_SECRETS)
&& (prop_spec->flags & NM_SETTING_PARAM_SECRET))
continue;
if ( (flags & NM_SETTING_HASH_FLAG_ONLY_SECRETS)
&& !(prop_spec->flags & NM_SETTING_PARAM_SECRET))
continue;
value = g_slice_new0 (GValue);
g_value_init (value, prop_spec->value_type);
g_object_get_property (G_OBJECT (setting), prop_spec->name, value);
/* Don't serialize values with default values */
if (!g_param_value_defaults (prop_spec, value))
g_hash_table_insert (hash, g_strdup (prop_spec->name), value);
else
destroy_gvalue (value);
}
g_free (property_specs);
/* Don't return empty hashes */
if (g_hash_table_size (hash) < 1) {
g_hash_table_destroy (hash);
hash = NULL;
}
return hash;
}
static JsonNode *
json_serializable_real_serialize (JsonSerializable *serializable,
const gchar *name,
const GValue *value,
GParamSpec *pspec)
{
JSON_NOTE (GOBJECT, "Default serialization for property '%s'", pspec->name);
if (g_param_value_defaults (pspec, (GValue *)value))
return NULL;
return json_serialize_pspec (value, pspec);
}
static VALUE
value_defaults(VALUE self, VALUE val)
{
GValue tmp = {0,};
gboolean result;
/* FIXME: use rb_ensure to ensure following g_value_unset() call*/
g_value_init(&tmp,
G_PARAM_SPEC_VALUE_TYPE(rbgobj_get_param_spec(self)));
rbgobj_rvalue_to_gvalue(val, &tmp);
result = g_param_value_defaults(rbgobj_get_param_spec(self), &tmp);
g_value_unset(&tmp);
return CBOOL2RVAL(result);
}
static gchar *
debug_dump_get_element_params (GstElement * element)
{
gchar *param_name = NULL;
GParamSpec **properties, *property;
GValue value = { 0, };
guint i, number_of_properties;
gchar *tmp, *value_str;
/* get paramspecs and show non-default properties */
properties =
g_object_class_list_properties (G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS
(element)), &number_of_properties);
if (properties) {
for (i = 0; i < number_of_properties; i++) {
property = properties[i];
/* ski some properties */
if (!(property->flags & G_PARAM_READABLE))
continue;
if (!strcmp (property->name, "name"))
continue;
g_value_init (&value, property->value_type);
g_object_get_property (G_OBJECT (element), property->name, &value);
if (!(g_param_value_defaults (property, &value))) {
tmp = g_strdup_value_contents (&value);
value_str = g_strescape (tmp, NULL);
g_free (tmp);
if (param_name) {
tmp = param_name;
param_name = g_strdup_printf ("%s\\n%s=%s",
tmp, property->name, value_str);
g_free (tmp);
} else {
param_name = g_strdup_printf ("\\n%s=%s", property->name, value_str);
}
g_free (value_str);
}
g_value_unset (&value);
}
g_free (properties);
}
return param_name;
}
static void
test_param_spec_char (void)
{
GParamSpec *pspec;
GValue value = { 0, };
gboolean modified;
pspec = g_param_spec_char ("char", "nick", "blurb",
20, 40, 30, G_PARAM_READWRITE);
//g_param_spec_ref_force_floating(pspec);
//g_assert(g_param_spec_is_floating(pspec));
g_param_spec_ref_sink(pspec);
g_assert (strcmp (g_param_spec_get_name (pspec), "char") == 0);
g_assert (strcmp (g_param_spec_get_nick (pspec), "nick") == 0);
g_assert (strcmp (g_param_spec_get_blurb (pspec), "blurb") == 0);
g_value_init (&value, G_TYPE_CHAR);
g_value_set_char (&value, 30);
g_assert (g_param_value_defaults (pspec, &value));
g_value_set_char (&value, 0);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_char (&value) == 20);
g_value_set_char (&value, 20);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_char (&value) == 20);
g_value_set_char (&value, 40);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_char (&value) == 40);
g_value_set_char (&value, 60);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_char (&value) == 40);
g_param_spec_unref (pspec);
}
static void
test_param_spec_gtype (void)
{
GParamSpec *pspec;
GValue value = { 0, };
gboolean modified;
pspec = g_param_spec_gtype ("gtype", "nick", "blurb",
G_TYPE_PARAM, G_PARAM_READWRITE);
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_PARAM);
g_assert (g_param_value_defaults (pspec, &value));
g_value_set_gtype (&value, G_TYPE_INT);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_gtype (&value) == G_TYPE_PARAM);
g_value_set_gtype (&value, G_TYPE_PARAM_INT);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_gtype (&value) == G_TYPE_PARAM_INT);
}
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 JsonObject *
json_gobject_dump (GObject *gobject)
{
JsonSerializableIface *iface = NULL;
JsonSerializable *serializable = NULL;
gboolean list_properties = FALSE;
gboolean serialize_property = FALSE;
gboolean get_property = FALSE;
JsonObject *object;
GParamSpec **pspecs;
guint n_pspecs, i;
if (JSON_IS_SERIALIZABLE (gobject))
{
serializable = JSON_SERIALIZABLE (gobject);
iface = JSON_SERIALIZABLE_GET_IFACE (gobject);
list_properties = (iface->list_properties != NULL);
serialize_property = (iface->serialize_property != NULL);
get_property = (iface->get_property != NULL);
}
object = json_object_new ();
if (list_properties)
pspecs = json_serializable_list_properties (serializable, &n_pspecs);
else
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (gobject), &n_pspecs);
for (i = 0; i < n_pspecs; i++)
{
GParamSpec *pspec = pspecs[i];
GValue value = { 0, };
JsonNode *node = NULL;
/* read only what we can */
if (!(pspec->flags & G_PARAM_READABLE))
continue;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
if (get_property)
json_serializable_get_property (serializable, pspec, &value);
else
g_object_get_property (gobject, pspec->name, &value);
/* if there is a serialization vfunc, then it is completely responsible
* for serializing the property, possibly by calling the implementation
* of the default JsonSerializable interface through chaining up
*/
if (serialize_property)
{
node = json_serializable_serialize_property (serializable,
pspec->name,
&value,
pspec);
}
/* skip if the value is the default for the property */
else if (!g_param_value_defaults (pspec, &value))
node = json_serialize_pspec (&value, pspec);
if (node)
json_object_set_member (object, pspec->name, node);
g_value_unset (&value);
}
g_free (pspecs);
return object;
}
static gchar *
debug_dump_get_element_params (GstElement * element,
GstDebugGraphDetails details)
{
gchar *param_name = NULL;
GParamSpec **properties, *property;
GValue value = { 0, };
guint i, number_of_properties;
gchar *tmp, *value_str;
const gchar *ellipses;
/* get paramspecs and show non-default properties */
properties =
g_object_class_list_properties (G_OBJECT_CLASS (GST_ELEMENT_GET_CLASS
(element)), &number_of_properties);
if (properties) {
for (i = 0; i < number_of_properties; i++) {
property = properties[i];
/* skip some properties */
if (!(property->flags & G_PARAM_READABLE))
continue;
if (!strcmp (property->name, "name"))
continue;
g_value_init (&value, property->value_type);
g_object_get_property (G_OBJECT (element), property->name, &value);
if (!(g_param_value_defaults (property, &value))) {
tmp = g_strdup_value_contents (&value);
value_str = g_strescape (tmp, NULL);
g_free (tmp);
/* too long, ellipsize */
if (!(details & GST_DEBUG_GRAPH_SHOW_FULL_PARAMS) &&
strlen (value_str) > PARAM_MAX_LENGTH)
ellipses = "…";
else
ellipses = "";
if (param_name)
tmp = param_name;
else
tmp = (char *) "";
if (details & GST_DEBUG_GRAPH_SHOW_FULL_PARAMS) {
param_name = g_strdup_printf ("%s\\n%s=%s", tmp, property->name,
value_str);
} else {
param_name = g_strdup_printf ("%s\\n%s=%."
G_STRINGIFY (PARAM_MAX_LENGTH) "s%s", tmp, property->name,
value_str, ellipses);
}
if (tmp[0] != '\0')
g_free (tmp);
g_free (value_str);
}
g_value_unset (&value);
}
g_free (properties);
}
return param_name;
}
void GOComponentView::update ()
{
UT_return_if_fail (component);
UT_Byte *buf;
int length;
void (*clearfunc) (gpointer);
gpointer user_data = NULL;
FV_View *pView = m_pRun->getBlock ()->getView ();
if (go_component_get_data (component, (void**) &buf, &length, &clearfunc, &user_data)) {
if (buf && length) {
UT_ByteBufPtr myByteBuf(new UT_ByteBuf);
myByteBuf->append(buf, length);
mime_type = component->mime_type;
UT_String Props="embed-type: GOComponent";
guint i, nbprops;
GType prop_type;
GValue value = G_VALUE_INIT;
char *prop = NULL;
GParamSpec **specs = g_object_class_list_properties (
G_OBJECT_GET_CLASS (component), &nbprops);
for (i = 0; i < nbprops; i++) {
if (specs[i]->flags & GO_PARAM_PERSISTENT) {
prop_type = G_PARAM_SPEC_VALUE_TYPE (specs[i]);
g_value_init (&value, prop_type);
g_object_get_property (G_OBJECT (component), specs[i]->name, &value);
if (!g_param_value_defaults (specs[i], &value))
switch (G_TYPE_FUNDAMENTAL (prop_type)) {
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
case G_TYPE_BOOLEAN:
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
GValue str = G_VALUE_INIT;
g_value_init (&str, G_TYPE_STRING);
g_value_transform (&value, &str);
prop = g_strdup (g_value_get_string (&str));
g_value_unset (&str);
break;
}
case G_TYPE_STRING: {
prop = g_strdup (g_value_get_string (&value));
break;
}
default:
prop = NULL;
break;
}
g_value_unset (&value);
if (prop) {
Props += UT_String_sprintf("; %s:%s", specs[i]->name, prop);
g_free (prop);
prop = NULL;
}
}
}
pView->cmdUpdateEmbed(m_pRun, myByteBuf, mime_type.c_str(), Props.c_str());
} else
pView->cmdDeleteEmbed(m_pRun);
if (clearfunc)
clearfunc ((user_data)? user_data: buf);
}
}
static void
changed_cb (GOComponent *component, gpointer data)
{
if (data != NULL)
{
GOComponentView * pGOComponentView = static_cast<GOComponentView*> (data);
pGOComponentView->update ();
}
else
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
UT_Byte *buf;
int length;
void (*clearfunc) (gpointer);
gpointer user_data = NULL;
if (go_component_get_data (component, (void**) &buf, &length, &clearfunc, &user_data)) {
if (buf && length) {
UT_ByteBufPtr myByteBuf(new UT_ByteBuf);
myByteBuf->append(buf, length);
UT_String Props="embed-type: GOComponent";
guint i, nbprops;
GType prop_type;
GValue value = G_VALUE_INIT;
char *prop = NULL;
GParamSpec **specs = g_object_class_list_properties (
G_OBJECT_GET_CLASS (component), &nbprops);
for (i = 0; i < nbprops; i++) {
if (specs[i]->flags & GO_PARAM_PERSISTENT) {
prop_type = G_PARAM_SPEC_VALUE_TYPE (specs[i]);
memset(&value, 0, sizeof(value));
g_value_init (&value, prop_type);
g_object_get_property (G_OBJECT (component), specs[i]->name, &value);
if (!g_param_value_defaults (specs[i], &value))
switch (G_TYPE_FUNDAMENTAL (prop_type)) {
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
case G_TYPE_BOOLEAN:
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
GValue str;
memset(&str, 0, sizeof(str));
g_value_init (&str, G_TYPE_STRING);
g_value_transform (&value, &str);
prop = g_strdup (g_value_get_string (&str));
g_value_unset (&str);
break;
}
case G_TYPE_STRING: {
prop = g_strdup (g_value_get_string (&value));
break;
}
default:
prop = NULL;
break;
}
g_value_unset (&value);
if (prop) {
Props += UT_String_sprintf("; %s:%s", specs[i]->name, prop);
g_free (prop);
prop = NULL;
}
}
}
PT_DocPosition pos = pView->getPoint();
pView->cmdInsertEmbed(myByteBuf, pView->getPoint(), component->mime_type, Props.c_str ());
pView->cmdSelect(pos,pos+1);
}
if (clearfunc)
clearfunc ((user_data)? user_data: buf);
}
g_object_unref (component); // destroy since we created a new one this will close the editor
}
}
