static GSList *
mc_load_macros (MCData *mc)
{
GConfValue *macro_patterns;
GConfValue *macro_commands;
GSList *macros_list = NULL;
GConfClient *client;
client = gconf_client_get_default ();
macro_patterns = gconf_client_get (client,
"/apps/mini-commander/macro_patterns", NULL);
macro_commands = gconf_client_get (client,
"/apps/mini-commander/macro_commands", NULL);
if (macro_patterns && macro_commands) {
GSList *patterns;
GSList *commands;
patterns = gconf_value_get_list (macro_patterns);
commands = gconf_value_get_list (macro_commands);
for (; patterns && commands; patterns = patterns->next, commands = commands->next) {
GConfValue *v1 = patterns->data;
GConfValue *v2 = commands->data;
MCMacro *macro;
const char *pattern, *command;
pattern = gconf_value_get_string (v1);
command = gconf_value_get_string (v2);
if (!(macro = mc_macro_new (pattern, command)))
continue;
macros_list = g_slist_prepend (macros_list, macro);
}
} else {
int i;
for (i = 0; i < G_N_ELEMENTS (mc_default_macros); i++)
macros_list = g_slist_prepend (macros_list,
mc_macro_new (mc_default_macros [i].pattern,
mc_default_macros [i].command));
}
macros_list = g_slist_reverse (macros_list);
if (macro_commands)
gconf_value_free (macro_commands);
if (macro_patterns)
gconf_value_free (macro_patterns);
return macros_list;
}
static void
disabled_applets_notify (GConfClient *client,
guint cnxn_id,
GConfEntry *entry,
PanelLockdown *lockdown)
{
GSList *l;
if (!entry->value || entry->value->type != GCONF_VALUE_LIST ||
gconf_value_get_list_type (entry->value) != GCONF_VALUE_STRING)
return;
for (l = lockdown->disabled_applets; l; l = l->next)
g_free (l->data);
g_slist_free (lockdown->disabled_applets);
lockdown->disabled_applets = NULL;
for (l = gconf_value_get_list (entry->value); l; l = l->next) {
const char *iid = gconf_value_get_string (l->data);
lockdown->disabled_applets =
g_slist_prepend (lockdown->disabled_applets,
g_strdup (iid));
}
panel_lockdown_invoke_closures (lockdown);
}
/** Helper for appending gconf float list to dbus message
*
* @param conf GConfValue of float list type
* @param pcount number of items in the returned array is stored here
* @return array of doubles that can be easily added to DBusMessage
*/
static double *float_array_from_gconf_value(GConfValue *conf, int *pcount)
{
double *array = 0;
int count = 0;
GSList *list, *item;
if( conf->type != GCONF_VALUE_LIST )
goto EXIT;
if( gconf_value_get_list_type(conf) != GCONF_VALUE_FLOAT )
goto EXIT;
list = gconf_value_get_list(conf);
for( item = list; item; item = item->next )
++count;
array = g_malloc_n(count, sizeof *array);
count = 0;
for( item = list; item; item = item->next )
array[count++] = gconf_value_get_float(item->data);
EXIT:
return *pcount = count, array;
}
/* Fills a GtkListStore with the string list from @value */
static void
list_store_binding_sync_pref_to_store (ListStoreBinding *binding,
GConfValue *value)
{
GSList *list, *l;
GtkTreeIter iter;
/* Make sure we don't enter an infinite synchronizing loop */
g_signal_handler_block (binding->list_store,
binding->row_inserted_id);
g_signal_handler_block (binding->list_store,
binding->row_deleted_id);
gtk_list_store_clear (binding->list_store);
list = gconf_value_get_list (value);
for (l = list; l; l = l->next) {
GConfValue *l_value;
const char *string;
l_value = (GConfValue *) l->data;
string = gconf_value_get_string (l_value);
gtk_list_store_insert_with_values (binding->list_store,
&iter, -1,
0, string,
-1);
}
g_signal_handler_unblock (binding->list_store,
binding->row_inserted_id);
g_signal_handler_unblock (binding->list_store,
binding->row_deleted_id);
}
bool Conf::GetStringList(const gchar *key,
std::list < std::string > &list)
{
GConfValue *value = NULL;
GSList *slist = NULL;
if (!gconf_client)
return false;
value = gconf_client_get(gconf_client, key, NULL);
if (value) {
slist = gconf_value_get_list(value);
if (slist) {
GSList *entry = slist;
list.clear();
while (entry) {
list.push_back(std::string(gconf_value_get_string((GConfValue *)entry->data)));
entry = entry->next;
}
}
gconf_value_free(value);
} else {
return false;
}
return true;
}
static void
calendar_sources_selected_sources_notify (GConfClient *client,
guint cnx_id,
GConfEntry *entry,
CalendarSourceData *source_data)
{
GSList *l;
if (!entry->value ||
entry->value->type != GCONF_VALUE_LIST ||
gconf_value_get_list_type (entry->value) != GCONF_VALUE_STRING)
return;
dprintf ("Selected sources key (%s) changed, reloading\n", entry->key);
for (l = source_data->selected_sources; l; l = l->next)
g_free (l->data);
source_data->selected_sources = NULL;
for (l = gconf_value_get_list (entry->value); l; l = l->next)
{
const char *source = gconf_value_get_string (l->data);
source_data->selected_sources =
g_slist_prepend (source_data->selected_sources,
g_strdup (source));
}
source_data->selected_sources =
g_slist_reverse (source_data->selected_sources);
calendar_sources_load_esource_list (source_data);
}
GSList *
eel_gconf_value_get_string_list (const GConfValue *value)
{
GSList *result;
const GSList *slist;
const GSList *node;
const char *string;
const GConfValue *next_value;
if (value == NULL) {
return NULL;
}
g_return_val_if_fail (value->type == GCONF_VALUE_LIST, NULL);
g_return_val_if_fail (gconf_value_get_list_type (value) == GCONF_VALUE_STRING, NULL);
slist = gconf_value_get_list (value);
result = NULL;
for (node = slist; node != NULL; node = node->next) {
next_value = node->data;
g_return_val_if_fail (next_value != NULL, NULL);
g_return_val_if_fail (next_value->type == GCONF_VALUE_STRING, NULL);
string = gconf_value_get_string (next_value);
result = g_slist_prepend (result, g_strdup (string));
}
return g_slist_reverse (result);
}
/**
* Return an integer list from the specified GConf key
*
* @param key The GConf key to get the values from
* @param[out] values Will contain an GSList with the values on return
* @return TRUE on success, FALSE on failure
*/
gboolean mce_gconf_get_int_list(const gchar *const key, GSList **values)
{
gboolean status = FALSE;
GError *error = NULL;
GConfValue *gcv, *gcv2;
GSList *list;
gint i;
if( gconf_disabled ) {
mce_log(LL_DEBUG, "blocked %s query", key);
goto EXIT;
}
gcv = gconf_client_get(gconf_client, key, &error);
if (gcv == NULL) {
mce_log((error != NULL) ? LL_WARN : LL_INFO,
"Could not retrieve %s from GConf; %s",
key, (error != NULL) ? error->message : "Key not set");
goto EXIT;
}
if ((gcv->type != GCONF_VALUE_LIST) ||
(gconf_value_get_list_type(gcv) != GCONF_VALUE_INT)) {
mce_log(LL_ERR,
"GConf key %s should have type: %d<%d>, but has type: %d<%d>",
key, GCONF_VALUE_LIST, GCONF_VALUE_INT,
gcv->type, gconf_value_get_list_type(gcv));
goto EXIT;
}
list = gconf_value_get_list(gcv);
for (i = 0; (gcv2 = g_slist_nth_data(list, i)) != NULL; i++) {
gint data;
data = gconf_value_get_int(gcv2);
/* Prepend is more efficient than append */
*values = g_slist_prepend(*values, GINT_TO_POINTER(data));
}
/* Reverse the list, since we want the entries in the right order */
*values = g_slist_reverse(*values);
gconf_value_free(gcv);
status = TRUE;
EXIT:
g_clear_error(&error);
return status;
}
static QVariant convertValue(GConfValue *src)
{
if (!src) {
return QVariant();
} else {
switch (src->type) {
case GCONF_VALUE_INVALID:
return QVariant(QVariant::Invalid);
case GCONF_VALUE_BOOL:
return QVariant((bool)gconf_value_get_bool(src));
case GCONF_VALUE_INT:
return QVariant(gconf_value_get_int(src));
case GCONF_VALUE_FLOAT:
return QVariant(gconf_value_get_float(src));
case GCONF_VALUE_STRING:
return QVariant(QString::fromUtf8(gconf_value_get_string(src)));
case GCONF_VALUE_LIST:
switch (gconf_value_get_list_type(src)) {
case GCONF_VALUE_STRING:
{
QStringList result;
for (GSList *elts = gconf_value_get_list(src); elts; elts = elts->next)
result.append(QString::fromUtf8(gconf_value_get_string((GConfValue *)elts->data)));
return QVariant(result);
}
default:
{
QList<QVariant> result;
for (GSList *elts = gconf_value_get_list(src); elts; elts = elts->next)
result.append(convertValue((GConfValue *)elts->data));
return QVariant(result);
}
}
case GCONF_VALUE_SCHEMA:
default:
return QVariant();
}
}
}
static void
_from_gconf_value (GValue *value,
const GConfValue *gv)
{
g_assert (value);
g_assert (gv);
switch (gv->type) {
case GCONF_VALUE_STRING:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gconf_value_get_string (gv));
return;
case GCONF_VALUE_INT:
g_value_init (value, G_TYPE_INT);
g_value_set_int (value, gconf_value_get_int (gv));
return;
case GCONF_VALUE_FLOAT:
g_value_init (value, G_TYPE_DOUBLE);
g_value_set_double (value, gconf_value_get_float (gv));
return;
case GCONF_VALUE_BOOL:
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, gconf_value_get_bool (gv));
return;
case GCONF_VALUE_LIST:
{
g_value_init (value, G_TYPE_VALUE_ARRAY);
GSList *list, *p;
GValueArray *va;
list = gconf_value_get_list (gv);
va = g_value_array_new (g_slist_length (list));
for (p = list; p != NULL; p = p->next) {
GValue tmp = {0};
_from_gconf_value (&tmp, (GConfValue *) p->data);
g_value_array_append (va, &tmp);
}
g_value_take_boxed (value, va);
}
return;
default:
g_assert_not_reached ();
break;
}
}
GSList *
gm_conf_entry_get_list (GmConfEntry *entry)
{
GConfEntry *gconf_entry = NULL;
GSList *list = NULL;
GSList *it = NULL;
g_return_val_if_fail (entry != NULL, NULL);
gconf_entry = (GConfEntry *)entry;
if (gconf_entry->value)
it = gconf_value_get_list (gconf_entry->value);
while (it) {
list = g_slist_append (list, g_strdup ((char *) gconf_value_get_string (it->data)));
it = g_slist_next (it);
}
return list;
}
void
mc_load_preferences (MCData *mc)
{
GConfValue *history;
GError *error = NULL;
g_return_if_fail (mc != NULL);
g_return_if_fail (PANEL_IS_APPLET (mc->applet));
mc->preferences.show_default_theme =
panel_applet_gconf_get_bool (mc->applet, "show_default_theme", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.show_default_theme = MC_DEFAULT_SHOW_DEFAULT_THEME;
}
mc->preferences.auto_complete_history =
panel_applet_gconf_get_bool (mc->applet, "autocomplete_history", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.auto_complete_history = MC_DEFAULT_AUTO_COMPLETE_HISTORY;
}
mc->preferences.normal_size_x =
panel_applet_gconf_get_int (mc->applet, "normal_size_x", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.normal_size_x = MC_DEFAULT_NORMAL_SIZE_X;
}
mc->preferences.normal_size_x = MAX (mc->preferences.normal_size_x, 50);
mc->preferences.normal_size_y =
panel_applet_gconf_get_int (mc->applet, "normal_size_y", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.normal_size_y = MC_DEFAULT_NORMAL_SIZE_Y;
}
mc->preferences.normal_size_y = CLAMP (mc->preferences.normal_size_y, 5, 200);
mc->preferences.cmd_line_color_fg_r =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_fg_r", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_fg_r = MC_DEFAULT_CMD_LINE_COLOR_FG_R;
}
mc->preferences.cmd_line_color_fg_g =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_fg_g", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_fg_g = MC_DEFAULT_CMD_LINE_COLOR_FG_G;
}
mc->preferences.cmd_line_color_fg_b =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_fg_b", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_fg_b = MC_DEFAULT_CMD_LINE_COLOR_FG_B;
}
mc->preferences.cmd_line_color_bg_r =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_bg_r", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_bg_r = MC_DEFAULT_CMD_LINE_COLOR_BG_R;
}
mc->preferences.cmd_line_color_bg_g =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_bg_g", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_bg_g = MC_DEFAULT_CMD_LINE_COLOR_BG_G;
}
mc->preferences.cmd_line_color_bg_b =
panel_applet_gconf_get_int (mc->applet, "cmd_line_color_bg_b", &error);
if (error) {
g_error_free (error);
error = NULL;
mc->preferences.cmd_line_color_bg_b = MC_DEFAULT_CMD_LINE_COLOR_BG_B;
}
mc->preferences.macros = mc_load_macros (mc);
history = panel_applet_gconf_get_value (mc->applet, "history", NULL);
if (history) {
GSList *l;
for (l = gconf_value_get_list (history); l; l = l->next) {
const char *entry = NULL;
if ((entry = gconf_value_get_string (l->data)))
append_history_entry (mc, entry, TRUE);
}
gconf_value_free (history);
}
mc_setup_listeners (mc);
mc->preferences.idle_macros_loader_id = 0;
}
/* Helper for utils_append_value, writes a list. The "list" is a struct with the
* list type and an array with the values directly in it.
*/
static void
utils_append_value_helper_list (DBusMessageIter *main_iter,
const GConfValue *value)
{
DBusMessageIter struct_iter;
DBusMessageIter array_iter;
GConfValueType list_type;
const gchar *array_type;
GSList *list;
d(g_print ("Append value (list)\n"));
g_assert (value->type == GCONF_VALUE_LIST);
dbus_message_iter_open_container (main_iter,
DBUS_TYPE_STRUCT,
NULL, /* for struct */
&struct_iter);
/* Write the list type. */
list_type = gconf_value_get_list_type (value);
dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &list_type);
/* And the value. */
switch (list_type)
{
case GCONF_VALUE_INT:
array_type = DBUS_TYPE_INT32_AS_STRING;
break;
case GCONF_VALUE_STRING:
array_type = DBUS_TYPE_STRING_AS_STRING;
break;
case GCONF_VALUE_FLOAT:
array_type = DBUS_TYPE_DOUBLE_AS_STRING;
break;
case GCONF_VALUE_BOOL:
array_type = DBUS_TYPE_BOOLEAN_AS_STRING;
break;
case GCONF_VALUE_SCHEMA:
array_type = DBUS_TYPE_STRUCT_AS_STRING;
break;
default:
array_type = NULL;
g_assert_not_reached ();
}
dbus_message_iter_open_container (&struct_iter,
DBUS_TYPE_ARRAY,
array_type,
&array_iter);
list = gconf_value_get_list (value);
switch (list_type)
{
case GCONF_VALUE_STRING:
while (list)
{
const gchar *s;
s = gconf_value_get_string (list->data);
dbus_message_iter_append_basic (&array_iter,
DBUS_TYPE_STRING,
&s);
list = list->next;
}
break;
case GCONF_VALUE_INT:
while (list)
{
gint32 i;
i = gconf_value_get_int (list->data);
dbus_message_iter_append_basic (&array_iter,
DBUS_TYPE_INT32,
&i);
list = list->next;
}
break;
case GCONF_VALUE_FLOAT:
while (list)
{
gdouble d;
d = gconf_value_get_float (list->data);
dbus_message_iter_append_basic (&array_iter,
DBUS_TYPE_DOUBLE,
&d);
list = list->next;
}
break;
case GCONF_VALUE_BOOL:
while (list)
{
gboolean b;
b = gconf_value_get_bool (list->data);
dbus_message_iter_append_basic (&array_iter,
DBUS_TYPE_BOOLEAN,
&b);
list = list->next;
}
break;
case GCONF_VALUE_SCHEMA:
while (list)
{
GConfSchema *schema;
schema = gconf_value_get_schema (list->data);
utils_append_schema (&array_iter, schema);
list = list->next;
}
break;
default:
g_assert_not_reached ();
}
dbus_message_iter_close_container (&struct_iter, &array_iter);
dbus_message_iter_close_container (main_iter, &struct_iter);
}
static gboolean
handle_file (const gchar *filename)
{
GKeyFile *keyfile;
GConfClient *client;
GConfValue *value;
gint i, j;
gchar *gconf_key;
gchar **groups;
gchar **keys;
GVariantBuilder *builder;
GVariant *v;
const gchar *s;
gchar *str;
gint ii;
GSList *list, *l;
GSettingsSchemaSource *source;
GSettingsSchema *schema;
GSettings *settings;
GError *error;
keyfile = g_key_file_new ();
error = NULL;
if (!g_key_file_load_from_file (keyfile, filename, 0, &error))
{
if (verbose)
g_printerr ("%s: %s\n", filename, error->message);
g_error_free (error);
g_key_file_free (keyfile);
return FALSE;
}
client = get_writable_client ();
source = g_settings_schema_source_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);
schema = g_settings_schema_source_lookup (source, schema_path[0], TRUE);
if (schema == NULL)
{
if (verbose)
{
g_print ("Schema '%s' not found, skipping\n", schema_path[0]);
}
g_strfreev (schema_path);
continue;
}
g_settings_schema_unref (schema);
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 ((gconf_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 = gconf_client_get_without_default (client, gconf_key, &error)) == NULL)
{
if (error)
{
g_printerr ("Failed to get GConf key '%s': %s\n",
gconf_key, error->message);
g_error_free (error);
}
else
{
if (verbose)
g_print ("Skipping GConf key '%s', no user value\n",
gconf_key);
}
g_free (gconf_key);
continue;
}
switch (value->type)
{
case GCONF_VALUE_STRING:
if (dry_run)
g_print ("Set key '%s' to string '%s'\n", keys[j],
gconf_value_get_string (value));
else
g_settings_set (settings, keys[j], "s",
gconf_value_get_string (value));
break;
case GCONF_VALUE_INT:
if (dry_run)
g_print ("Set key '%s' to integer '%d'\n",
keys[j], gconf_value_get_int (value));
else
{
GVariant *range;
gchar *type;
range = g_settings_get_range (settings, keys[j]);
g_variant_get (range, "(&sv)", &type, NULL);
if (strcmp (type, "enum") == 0)
g_settings_set_enum (settings, keys[j], gconf_value_get_int (value));
else if (strcmp (type, "flags") == 0)
g_settings_set_flags (settings, keys[j], gconf_value_get_int (value));
else if (type_uint32 (settings, keys[j]))
g_settings_set (settings, keys[j], "u",
gconf_value_get_int (value));
else
g_settings_set (settings, keys[j], "i",
gconf_value_get_int (value));
g_variant_unref (range);
}
break;
case GCONF_VALUE_BOOL:
if (dry_run)
g_print ("Set key '%s' to boolean '%d'\n",
keys[j], gconf_value_get_bool (value));
else
g_settings_set (settings, keys[j], "b",
gconf_value_get_bool (value));
break;
case GCONF_VALUE_FLOAT:
if (dry_run)
g_print ("Set key '%s' to double '%g'\n",
keys[j], gconf_value_get_float (value));
else
g_settings_set (settings, keys[j], "d",
gconf_value_get_float (value));
break;
case GCONF_VALUE_LIST:
switch (gconf_value_get_list_type (value))
{
case GCONF_VALUE_STRING:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = gconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
GConfValue *lv = l->data;
s = gconf_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 GCONF_VALUE_INT:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = gconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
GConfValue *lv = l->data;
ii = gconf_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",
gconf_value_type_to_string (gconf_value_get_list_type (value)));
break;
}
break;
default:
g_printerr ("Keys of type %s not handled yet\n",
gconf_value_type_to_string (value->type));
break;
}
gconf_value_free (value);
g_free (gconf_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;
}
gboolean
eel_gconf_value_is_equal (const GConfValue *a,
const GConfValue *b)
{
GSList *node_a;
GSList *node_b;
if (a == NULL && b == NULL) {
return TRUE;
}
if (a == NULL || b == NULL) {
return FALSE;
}
if (a->type != b->type) {
return FALSE;
}
switch (a->type) {
case GCONF_VALUE_STRING:
case GCONF_VALUE_INT:
case GCONF_VALUE_FLOAT:
case GCONF_VALUE_BOOL:
return simple_value_is_equal (a, b);
break;
case GCONF_VALUE_LIST:
if (gconf_value_get_list_type (a) !=
gconf_value_get_list_type (b)) {
return FALSE;
}
node_a = gconf_value_get_list (a);
node_b = gconf_value_get_list (b);
if (node_a == NULL && node_b == NULL) {
return TRUE;
}
if (g_slist_length (node_a) !=
g_slist_length (node_b)) {
return FALSE;
}
for (;
node_a != NULL && node_b != NULL;
node_a = node_a->next, node_b = node_b->next) {
g_assert (node_a->data != NULL);
g_assert (node_b->data != NULL);
if (!simple_value_is_equal (node_a->data, node_b->data)) {
return FALSE;
}
}
return TRUE;
default:
/* FIXME: pair ? */
g_assert (0);
}
g_assert_not_reached ();
return FALSE;
}
static GVariant *
gconf_settings_backend_gconf_value_to_gvariant (GConfValue *gconf_value,
const GVariantType *expected_type)
{
switch (gconf_value->type)
{
case GCONF_VALUE_STRING:
case GCONF_VALUE_INT:
case GCONF_VALUE_FLOAT:
case GCONF_VALUE_BOOL:
if (!gconf_settings_backend_simple_gconf_value_type_is_compatible (gconf_value->type, expected_type))
return NULL;
return gconf_settings_backend_simple_gconf_value_type_to_gvariant (gconf_value, expected_type);
case GCONF_VALUE_LIST:
{
GConfValueType list_type;
const GVariantType *array_type;
GSList *list;
GPtrArray *array;
GVariant *result;
if (!g_variant_type_is_array (expected_type))
return NULL;
list_type = gconf_value_get_list_type (gconf_value);
array_type = g_variant_type_element (expected_type);
if (!gconf_settings_backend_simple_gconf_value_type_is_compatible (list_type, array_type))
return NULL;
array = g_ptr_array_new ();
for (list = gconf_value_get_list (gconf_value); list != NULL; list = list->next)
{
GVariant *variant;
variant = gconf_settings_backend_simple_gconf_value_type_to_gvariant (list->data, array_type);
g_ptr_array_add (array, variant);
}
result = g_variant_new_array (array_type, (GVariant **) array->pdata, array->len);
g_ptr_array_free (array, TRUE);
return result;
}
break;
case GCONF_VALUE_PAIR:
{
GConfValue *car;
GConfValue *cdr;
const GVariantType *first_type;
const GVariantType *second_type;
GVariant *tuple[2];
GVariant *result;
if (!g_variant_type_is_tuple (expected_type) ||
g_variant_type_n_items (expected_type) != 2)
return NULL;
car = gconf_value_get_car (gconf_value);
cdr = gconf_value_get_cdr (gconf_value);
first_type = g_variant_type_first (expected_type);
second_type = g_variant_type_next (first_type);
if (!gconf_settings_backend_simple_gconf_value_type_is_compatible (car->type, first_type) ||
!gconf_settings_backend_simple_gconf_value_type_is_compatible (cdr->type, second_type))
return NULL;
tuple[0] = gconf_settings_backend_simple_gconf_value_type_to_gvariant (car, first_type);
tuple[1] = gconf_settings_backend_simple_gconf_value_type_to_gvariant (cdr, second_type);
result = g_variant_new_tuple (tuple, 2);
return result;
}
break;
default:
return NULL;
}
g_assert_not_reached ();
return NULL;
}
static void
node_set_value(xmlNodePtr node, GConfValue* value)
{
const gchar* type;
gchar* value_str;
g_return_if_fail(node != NULL);
g_return_if_fail(value != NULL);
g_return_if_fail(value->type != GCONF_VALUE_INVALID);
type = gconf_value_type_to_string(value->type);
g_assert(type != NULL);
my_xmlSetProp(node, "type", type);
switch (value->type)
{
case GCONF_VALUE_INT:
case GCONF_VALUE_FLOAT:
case GCONF_VALUE_BOOL:
free_childs(node);
value_str = gconf_value_to_string(value);
my_xmlSetProp(node, "value", value_str);
g_free(value_str);
break;
case GCONF_VALUE_STRING:
{
xmlChar* encoded;
free_childs(node);
encoded = xmlEncodeEntitiesReentrant(node->doc,
(xmlChar *)gconf_value_get_string(value));
xmlNewChild(node, NULL, (xmlChar *)"stringvalue",
encoded);
xmlFree(encoded);
}
break;
case GCONF_VALUE_SCHEMA:
{
node_set_schema_value(node, value);
}
break;
case GCONF_VALUE_LIST:
{
GSList* list;
free_childs(node);
my_xmlSetProp(node, "ltype",
gconf_value_type_to_string(gconf_value_get_list_type(value)));
/* Add a new child for each node */
list = gconf_value_get_list(value);
while (list != NULL)
{
xmlNodePtr child;
/* this is O(1) because libxml saves the list tail */
child = xmlNewChild(node, NULL, (xmlChar *)"li", NULL);
g_return_if_fail(list->data != NULL);
node_set_value(child, (GConfValue*)list->data);
list = g_slist_next(list);
}
}
break;
case GCONF_VALUE_PAIR:
{
xmlNodePtr car, cdr;
free_childs(node);
car = xmlNewChild(node, NULL, (xmlChar *)"car", NULL);
cdr = xmlNewChild(node, NULL, (xmlChar *)"cdr", NULL);
g_return_if_fail(gconf_value_get_car(value) != NULL);
g_return_if_fail(gconf_value_get_cdr(value) != NULL);
node_set_value(car, gconf_value_get_car(value));
node_set_value(cdr, gconf_value_get_cdr(value));
}
break;
default:
g_assert_not_reached();
break;
}
}
