/* Writes a schema, which is a struct. */
static void
utils_append_schema (DBusMessageIter *main_iter,
const GConfSchema *schema)
{
DBusMessageIter struct_iter;
gint32 i;
const gchar *s;
GConfValue *default_value;
dbus_message_iter_open_container (main_iter,
DBUS_TYPE_STRUCT,
NULL, /* for structs */
&struct_iter);
i = gconf_schema_get_type (schema);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &i);
i = gconf_schema_get_list_type (schema);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &i);
i = gconf_schema_get_car_type (schema);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &i);
i = gconf_schema_get_cdr_type (schema);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &i);
s = gconf_schema_get_locale (schema);
utils_append_optional_string (&struct_iter, s);
s = gconf_schema_get_short_desc (schema);
utils_append_optional_string (&struct_iter, s);
s = gconf_schema_get_long_desc (schema);
utils_append_optional_string (&struct_iter, s);
s = gconf_schema_get_owner (schema);
utils_append_optional_string (&struct_iter, s);
default_value = gconf_schema_get_default_value (schema);
/* We don't need to do this, but it's much simpler */
if (default_value)
{
gchar *encoded;
encoded = gconf_value_encode (default_value);
g_assert (encoded != NULL);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING, &encoded);
g_free (encoded);
}
else
{
s = "";
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING, &s);
}
if (!dbus_message_iter_close_container (main_iter, &struct_iter))
g_error ("Out of memory");
}
GConfValue*
entry_get_value(Entry* e, const gchar** locales, GError** err)
{
const gchar* sl;
g_return_val_if_fail(e != NULL, NULL);
if (e->cached_value == NULL)
return NULL;
/* only schemas have locales for now anyway */
if (e->cached_value->type != GCONF_VALUE_SCHEMA)
return e->cached_value;
g_assert(e->cached_value->type == GCONF_VALUE_SCHEMA);
sl = gconf_schema_get_locale(gconf_value_get_schema(e->cached_value));
gconf_log (GCL_DEBUG, "Cached schema value has locale \"%s\", looking for %s",
sl ? sl : "null",
locales && locales [0] ? locales[0] : "null");
/* optimize most common cases first */
if (sl == NULL && (locales == NULL ||
*locales == NULL))
return e->cached_value;
else if (sl && locales && *locales &&
strcmp(sl, *locales) == 0)
return e->cached_value;
else
{
/* We want a locale other than the currently-loaded one */
GConfValue* newval;
GError* error = NULL;
entry_sync_if_needed(e);
newval = node_extract_value(e->node, locales, &error);
if (newval != NULL)
{
/* We found a schema with an acceptable locale */
gconf_value_free(e->cached_value);
e->cached_value = newval;
g_return_val_if_fail(error == NULL, e->cached_value);
}
else if (error != NULL)
{
/* There was an error */
gconf_log(GCL_WARNING, _("Ignoring XML node with name `%s': %s"),
e->name, error->message);
g_error_free(error);
/* Fall back to currently-loaded thing if any */
}
/* else fall back to the currently-loaded schema */
}
return e->cached_value;
}
static void
node_set_schema_value(xmlNodePtr node,
GConfValue* value)
{
GConfSchema* sc;
const gchar* locale;
const gchar* type;
xmlNodePtr found = NULL;
sc = gconf_value_get_schema (value);
/* Set the types */
if (gconf_schema_get_list_type (sc) != GCONF_VALUE_INVALID)
{
type = gconf_value_type_to_string(gconf_schema_get_list_type (sc));
g_assert(type != NULL);
my_xmlSetProp(node, "list_type", type);
}
if (gconf_schema_get_car_type (sc) != GCONF_VALUE_INVALID)
{
type = gconf_value_type_to_string(gconf_schema_get_car_type (sc));
g_assert(type != NULL);
my_xmlSetProp(node, "car_type", type);
}
if (gconf_schema_get_cdr_type (sc) != GCONF_VALUE_INVALID)
{
type = gconf_value_type_to_string(gconf_schema_get_cdr_type (sc));
g_assert(type != NULL);
my_xmlSetProp(node, "cdr_type", type);
}
/* unset this in case the node was previously a different type */
my_xmlSetProp(node, "value", NULL);
/* set the cross-locale attributes */
my_xmlSetProp(node, "stype", gconf_value_type_to_string(gconf_schema_get_type (sc)));
my_xmlSetProp(node, "owner", gconf_schema_get_owner (sc));
locale = gconf_schema_get_locale(sc);
gconf_log(GCL_DEBUG, "Setting XML node to schema with locale `%s'",
locale);
/* Find the node for this locale */
found = find_schema_subnode_by_locale(node, locale);
if (found == NULL)
found = xmlNewChild(node, NULL, (xmlChar *)"local_schema", NULL);
/* OK if these are set to NULL, since that unsets the property */
my_xmlSetProp(found, "locale", gconf_schema_get_locale (sc));
my_xmlSetProp(found, "short_desc", gconf_schema_get_short_desc (sc));
free_childs(found);
if (gconf_schema_get_default_value (sc) != NULL)
{
xmlNodePtr default_value_node;
default_value_node = xmlNewChild(found, NULL, (xmlChar *)"default", NULL);
node_set_value(default_value_node, gconf_schema_get_default_value (sc));
}
if (gconf_schema_get_long_desc (sc))
{
xmlNewChild(found, NULL, (xmlChar *)"longdesc",
(xmlChar *)gconf_schema_get_long_desc (sc));
}
}
