MateConfValue*
mateconf_sources_query_default_value(MateConfSources* sources,
const gchar* key,
const gchar** locales,
gboolean* is_writable,
GError** err)
{
GError* error = NULL;
MateConfValue* val;
MateConfMetaInfo* mi;
g_return_val_if_fail(err == NULL || *err == NULL, NULL);
if (is_writable)
*is_writable = key_is_writable (sources, NULL, key, NULL);
mi = mateconf_sources_query_metainfo(sources, key,
&error);
if (mi == NULL)
{
if (error != NULL)
{
if (err)
*err = error;
else
{
mateconf_log(GCL_ERR, _("Error getting metainfo: %s"), error->message);
g_error_free(error);
}
}
return NULL;
}
if (mateconf_meta_info_get_schema(mi) == NULL)
{
mateconf_meta_info_free(mi);
return NULL;
}
val = mateconf_sources_query_value(sources,
mateconf_meta_info_get_schema(mi), locales,
TRUE, NULL, NULL, NULL, &error);
if (val != NULL)
{
MateConfSchema* schema;
if (val->type != MATECONF_VALUE_SCHEMA)
{
mateconf_log(GCL_WARNING,
_("Key `%s' listed as schema for key `%s' actually stores type `%s'"),
mateconf_meta_info_get_schema(mi),
key,
mateconf_value_type_to_string(val->type));
mateconf_meta_info_free(mi);
return NULL;
}
mateconf_meta_info_free(mi);
schema = mateconf_value_steal_schema (val);
mateconf_value_free (val);
if (schema != NULL)
{
MateConfValue* retval;
retval = mateconf_schema_steal_default_value (schema);
mateconf_schema_free (schema);
return retval;
}
return NULL;
}
else
{
if (error != NULL)
{
if (err)
*err = error;
else
{
mateconf_log(GCL_ERR, _("Error getting value for `%s': %s"),
mateconf_meta_info_get_schema(mi),
error->message);
g_error_free(error);
}
}
mateconf_meta_info_free(mi);
return NULL;
}
}
gchar*
mateconf_value_to_string(const MateConfValue* value)
{
/* These strings shouldn't be translated; they're primarily
intended for machines to read, not humans, though I do
use them in some debug spew
*/
gchar* retval = NULL;
switch (value->type)
{
case MATECONF_VALUE_INT:
retval = g_strdup_printf("%d", mateconf_value_get_int(value));
break;
case MATECONF_VALUE_FLOAT:
retval = mateconf_double_to_string(mateconf_value_get_float(value));
break;
case MATECONF_VALUE_STRING:
retval = g_strdup(mateconf_value_get_string(value));
break;
case MATECONF_VALUE_BOOL:
retval = mateconf_value_get_bool(value) ? g_strdup("true") : g_strdup("false");
break;
case MATECONF_VALUE_LIST:
{
GSList* list;
list = mateconf_value_get_list(value);
if (list == NULL)
retval = g_strdup("[]");
else
{
gchar* buf = NULL;
guint bufsize = 64;
guint cur = 0;
g_assert(list != NULL);
buf = g_malloc(bufsize+3); /* my +3 superstition */
buf[0] = '[';
++cur;
g_assert(cur < bufsize);
while (list != NULL)
{
gchar* tmp;
gchar* elem;
guint len;
tmp = mateconf_value_to_string((MateConfValue*)list->data);
g_assert(tmp != NULL);
elem = escape_string(tmp, ",]");
g_free(tmp);
len = strlen(elem);
if ((cur + len + 2) >= bufsize) /* +2 for '\0' and comma */
{
bufsize = MAX(bufsize*2, bufsize+len+4);
buf = g_realloc(buf, bufsize+3);
}
g_assert(cur < bufsize);
strcpy(&buf[cur], elem);
cur += len;
g_assert(cur < bufsize);
g_free(elem);
buf[cur] = ',';
++cur;
g_assert(cur < bufsize);
list = g_slist_next(list);
}
g_assert(cur < bufsize);
buf[cur-1] = ']'; /* overwrites last comma */
buf[cur] = '\0';
retval = buf;
}
}
break;
case MATECONF_VALUE_PAIR:
{
gchar* tmp;
gchar* car;
gchar* cdr;
if (mateconf_value_get_car (value))
tmp = mateconf_value_to_string(mateconf_value_get_car(value));
else
tmp = g_strdup ("nil");
car = escape_string(tmp, ",)");
g_free(tmp);
if (mateconf_value_get_cdr (value))
tmp = mateconf_value_to_string(mateconf_value_get_cdr(value));
else
tmp = g_strdup ("nil");
cdr = escape_string(tmp, ",)");
g_free(tmp);
retval = g_strdup_printf("(%s,%s)", car, cdr);
g_free(car);
g_free(cdr);
}
break;
/* These remaining shouldn't really be used outside of debug spew... */
case MATECONF_VALUE_INVALID:
retval = g_strdup("Invalid");
break;
case MATECONF_VALUE_SCHEMA:
{
const gchar* locale;
const gchar* type;
const gchar* list_type;
const gchar* car_type;
const gchar* cdr_type;
locale = mateconf_schema_get_locale(mateconf_value_get_schema(value));
type = mateconf_value_type_to_string(mateconf_schema_get_type(mateconf_value_get_schema(value)));
list_type = mateconf_value_type_to_string(mateconf_schema_get_list_type(mateconf_value_get_schema(value)));
car_type = mateconf_value_type_to_string(mateconf_schema_get_car_type(mateconf_value_get_schema(value)));
cdr_type = mateconf_value_type_to_string(mateconf_schema_get_cdr_type(mateconf_value_get_schema(value)));
retval = g_strdup_printf("Schema (type: `%s' list_type: '%s' "
"car_type: '%s' cdr_type: '%s' locale: `%s')",
type, list_type, car_type, cdr_type,
locale ? locale : "(null)");
}
break;
default:
g_assert_not_reached();
break;
}
return retval;
}
static gboolean
handle_file (const gchar *filename)
{
GKeyFile *keyfile;
MateConfClient *client;
MateConfValue *value;
gint i, j;
gchar *mateconf_key;
gchar **groups;
gchar **keys;
GVariantBuilder *builder;
GVariant *v;
const gchar *s;
gchar *str;
gint ii;
GSList *list, *l;
GSettings *settings;
GError *error;
keyfile = g_key_file_new ();
error = NULL;
if (!g_key_file_load_from_file (keyfile, filename, 0, &error))
{
g_printerr ("%s\n", error->message);
g_error_free (error);
g_key_file_free (keyfile);
return FALSE;
}
client = mateconf_client_get_default ();
groups = g_key_file_get_groups (keyfile, NULL);
for (i = 0; groups[i]; i++)
{
gchar **schema_path;
schema_path = g_strsplit (groups[i], ":", 2);
if (verbose)
{
g_print ("collecting settings for schema '%s'\n", schema_path[0]);
if (schema_path[1])
g_print ("for storage at '%s'\n", schema_path[1]);
}
if (schema_path[1] != NULL)
settings = g_settings_new_with_path (schema_path[0], schema_path[1]);
else
settings = g_settings_new (schema_path[0]);
g_settings_delay (settings);
error = NULL;
if ((keys = g_key_file_get_keys (keyfile, groups[i], NULL, &error)) == NULL)
{
g_printerr ("%s", error->message);
g_error_free (error);
continue;
}
for (j = 0; keys[j]; j++)
{
if (strchr (keys[j], '/') != 0)
{
g_printerr ("Key '%s' contains a '/'\n", keys[j]);
continue;
}
error = NULL;
if ((mateconf_key = g_key_file_get_string (keyfile, groups[i], keys[j], &error)) == NULL)
{
g_printerr ("%s", error->message);
g_error_free (error);
continue;
}
error = NULL;
if ((value = mateconf_client_get_without_default (client, mateconf_key, &error)) == NULL)
{
if (error)
{
g_printerr ("Failed to get MateConf key '%s': %s\n",
mateconf_key, error->message);
g_error_free (error);
}
else
{
if (verbose)
g_print ("Skipping MateConf key '%s', no user value\n",
mateconf_key);
}
g_free (mateconf_key);
continue;
}
switch (value->type)
{
case MATECONF_VALUE_STRING:
if (dry_run)
g_print ("set key '%s' to string '%s'\n", keys[j],
mateconf_value_get_string (value));
else
g_settings_set (settings, keys[j], "s",
mateconf_value_get_string (value));
break;
case MATECONF_VALUE_INT:
if (dry_run)
g_print ("set key '%s' to integer '%d'\n",
keys[j], mateconf_value_get_int (value));
else
g_settings_set (settings, keys[j], "i",
mateconf_value_get_int (value));
break;
case MATECONF_VALUE_BOOL:
if (dry_run)
g_print ("set key '%s' to boolean '%d'\n",
keys[j], mateconf_value_get_bool (value));
else
g_settings_set (settings, keys[j], "b",
mateconf_value_get_bool (value));
break;
case MATECONF_VALUE_FLOAT:
if (dry_run)
g_print ("set key '%s' to double '%g'\n",
keys[j], mateconf_value_get_float (value));
else
g_settings_set (settings, keys[j], "d",
mateconf_value_get_float (value));
break;
case MATECONF_VALUE_LIST:
switch (mateconf_value_get_list_type (value))
{
case MATECONF_VALUE_STRING:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = mateconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
MateConfValue *lv = l->data;
s = mateconf_value_get_string (lv);
g_variant_builder_add (builder, "s", s);
}
v = g_variant_new ("as", builder);
}
else
v = g_variant_new_array (G_VARIANT_TYPE_STRING, NULL, 0);
g_variant_ref_sink (v);
if (dry_run)
{
str = g_variant_print (v, FALSE);
g_print ("set key '%s' to a list of strings: %s\n",
keys[j], str);
g_free (str);
}
else
g_settings_set_value (settings, keys[j], v);
g_variant_unref (v);
g_variant_builder_unref (builder);
break;
case MATECONF_VALUE_INT:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = mateconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
MateConfValue *lv = l->data;
ii = mateconf_value_get_int (lv);
g_variant_builder_add (builder, "i", ii);
}
v = g_variant_new ("ai", builder);
}
else
v = g_variant_new_array (G_VARIANT_TYPE_INT32, NULL, 0);
g_variant_ref_sink (v);
if (dry_run)
{
str = g_variant_print (v, FALSE);
g_print ("set key '%s' to a list of integers: %s\n",
keys[j], str);
g_free (str);
}
else
g_settings_set_value (settings, keys[j], v);
g_variant_unref (v);
g_variant_builder_unref (builder);
break;
default:
g_printerr ("Keys of type 'list of %s' not handled yet\n",
mateconf_value_type_to_string (mateconf_value_get_list_type (value)));
break;
}
break;
default:
g_printerr ("Keys of type %s not handled yet\n",
mateconf_value_type_to_string (value->type));
break;
}
mateconf_value_free (value);
g_free (mateconf_key);
}
g_strfreev (keys);
if (!dry_run)
g_settings_apply (settings);
g_object_unref (settings);
g_strfreev (schema_path);
}
g_strfreev (groups);
g_object_unref (client);
return TRUE;
}
