/* Properties dialog
*/
static void
save_macros_to_gconf (MCData *mc)
{
MCPrefsDialog *dialog;
GtkTreeIter iter;
GConfValue *patterns;
GConfValue *commands;
GSList *pattern_list = NULL;
GSList *command_list = NULL;
GConfClient *client;
dialog = &mc->prefs_dialog;
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->macros_store), &iter))
return;
patterns = gconf_value_new (GCONF_VALUE_LIST);
gconf_value_set_list_type (patterns, GCONF_VALUE_STRING);
commands = gconf_value_new (GCONF_VALUE_LIST);
gconf_value_set_list_type (commands, GCONF_VALUE_STRING);
do {
char *pattern = NULL;
char *command = NULL;
gtk_tree_model_get (
GTK_TREE_MODEL (dialog->macros_store), &iter,
0, &pattern,
1, &command,
-1);
pattern_list = g_slist_prepend (pattern_list,
gconf_value_new_from_string (GCONF_VALUE_STRING, pattern, NULL));
command_list = g_slist_prepend (command_list,
gconf_value_new_from_string (GCONF_VALUE_STRING, command, NULL));
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (dialog->macros_store), &iter));
pattern_list = g_slist_reverse (pattern_list);
command_list = g_slist_reverse (command_list);
gconf_value_set_list_nocopy (patterns, pattern_list); pattern_list = NULL;
gconf_value_set_list_nocopy (commands, command_list); command_list = NULL;
client = gconf_client_get_default ();
gconf_client_set (client, "/apps/mini-commander/macro_patterns",
patterns, NULL);
gconf_client_set (client, "/apps/mini-commander/macro_commands",
commands, NULL);
gconf_value_free (patterns);
gconf_value_free (commands);
}
static void
install_default_macros_list (GConfClient *client,
const char *key,
int offset)
{
GConfSchema *schema;
GConfValue *value;
GSList *list = NULL;
GError *error;
int i;
error = NULL;
schema = gconf_client_get_schema (client, key, &error);
if (error) {
g_warning (_("Cannot get schema for %s: %s"), key, error->message);
g_error_free (error);
return;
}
/* gconf has started to return NULL with no error set. */
g_return_if_fail (schema != NULL);
/* Some sanity checks */
g_assert (gconf_schema_get_type (schema) == GCONF_VALUE_LIST);
g_assert (gconf_schema_get_list_type (schema) == GCONF_VALUE_STRING);
value = gconf_value_new (GCONF_VALUE_LIST);
gconf_value_set_list_type (value, GCONF_VALUE_STRING);
for (i = 0; i < G_N_ELEMENTS (mc_default_macros); i++)
list = g_slist_prepend (list,
gconf_value_new_from_string (GCONF_VALUE_STRING,
G_STRUCT_MEMBER (char *, &mc_default_macros [i], offset),
NULL));
list = g_slist_reverse (list);
gconf_value_set_list_nocopy (value, list);
list = NULL;
gconf_schema_set_default_value_nocopy (schema, value);
value = NULL;
error = NULL;
gconf_client_set_schema (client, key, schema, &error);
if (error) {
g_warning (_("Cannot set schema for %s: %s"), key, error->message);
g_error_free (error);
}
gconf_schema_free (schema);
printf (_("Set default list value for %s\n"), key);
}
/* Sets a GConf value to the contents of a GtkListStore */
static gboolean
list_store_binding_sync_store_to_pref (ListStoreBinding *binding)
{
GtkTreeModel *tree_model;
GtkTreeIter iter;
GSList *list;
int res;
GConfValue *gconf_value;
tree_model = GTK_TREE_MODEL (binding->list_store);
/* Build list */
list = NULL;
res = gtk_tree_model_get_iter_first (tree_model, &iter);
while (res) {
char *string;
GConfValue *tmp_value;
gtk_tree_model_get (tree_model, &iter,
0, &string, -1);
tmp_value = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (tmp_value, string);
list = g_slist_append (list, tmp_value);
res = gtk_tree_model_iter_next (tree_model, &iter);
}
/* Create value */
gconf_value = gconf_value_new (GCONF_VALUE_LIST);
gconf_value_set_list_type (gconf_value, GCONF_VALUE_STRING);
gconf_value_set_list_nocopy (gconf_value, list);
/* Set */
gconf_client_set (bridge->client, binding->key, gconf_value, NULL);
/* Store until change notification comes in, so that we are able
* to ignore it */
binding->val_changes = g_slist_append (binding->val_changes,
gconf_value);
binding->sync_idle_id = 0;
g_object_unref (binding->list_store);
return FALSE;
}
static GConfValue *
_to_gconf_value (const GValue *value)
{
GConfValue *gv;
GType type = G_VALUE_TYPE (value);
switch (type) {
case G_TYPE_STRING:
{
gv = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (gv, g_value_get_string (value));
}
break;
case G_TYPE_INT:
{
gv = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gv, g_value_get_int (value));
}
break;
case G_TYPE_UINT:
{
gv = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gv, g_value_get_uint (value));
}
break;
case G_TYPE_BOOLEAN:
{
gv = gconf_value_new (GCONF_VALUE_BOOL);
gconf_value_set_bool (gv, g_value_get_boolean (value));
}
break;
case G_TYPE_DOUBLE:
{
gv = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (gv, g_value_get_double (value));
}
break;
case G_TYPE_FLOAT:
{
gv = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (gv, g_value_get_float (value));
}
break;
default:
if (type == G_TYPE_VALUE_ARRAY) {
GSList *l = NULL;
GType list_type = G_TYPE_STRING;
GValueArray *array = g_value_get_boxed (value);
gint i;
if (array && array->n_values > 0) {
list_type = G_VALUE_TYPE (&(array->values[0]));
}
gv = gconf_value_new (GCONF_VALUE_LIST);
switch (list_type) {
case G_TYPE_STRING:
gconf_value_set_list_type (gv, GCONF_VALUE_STRING); break;
case G_TYPE_INT:
case G_TYPE_UINT:
gconf_value_set_list_type (gv, GCONF_VALUE_INT); break;
case G_TYPE_BOOLEAN:
gconf_value_set_list_type (gv, GCONF_VALUE_BOOL); break;
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
gconf_value_set_list_type (gv, GCONF_VALUE_FLOAT); break;
default:
g_assert_not_reached ();
}
for (i = 0; array && i < array->n_values; i++) {
GConfValue *tmp;
g_assert (G_VALUE_TYPE (&(array->values[i])) == list_type);
tmp = _to_gconf_value (&(array->values[i]));
l = g_slist_append (l, tmp);
}
gconf_value_set_list_nocopy (gv, l);
}
else
g_assert_not_reached ();
}
return gv;
}
static GConfValue *
gconf_settings_backend_gvariant_to_gconf_value (GVariant *value)
{
const GVariantType *type;
GConfValue *gconf_value = NULL;
type = g_variant_get_type (value);
if (g_variant_type_is_basic (type) &&
!g_variant_type_equal (type, G_VARIANT_TYPE_BASIC))
gconf_value = gconf_settings_backend_simple_gvariant_to_gconf_value (value, type);
else if (g_variant_type_is_array (type))
{
const GVariantType *array_type;
array_type = g_variant_type_element (type);
if (g_variant_type_is_basic (array_type) &&
!g_variant_type_equal (array_type, G_VARIANT_TYPE_BASIC))
{
GConfValueType value_type;
int i;
GSList *list = NULL;
for (i = 0; i < g_variant_n_children (value); i++)
{
GConfValue *l;
l = gconf_settings_backend_simple_gvariant_to_gconf_value (g_variant_get_child_value (value, i),
array_type);
list = g_slist_prepend (list, l);
}
list = g_slist_reverse (list);
value_type = gconf_settings_backend_simple_gvariant_type_to_gconf_value_type (array_type);
gconf_value = gconf_value_new (GCONF_VALUE_LIST);
gconf_value_set_list_type (gconf_value, value_type);
gconf_value_set_list (gconf_value, list);
g_slist_foreach (list, (GFunc) gconf_value_free, NULL);
g_slist_free (list);
}
}
else if (g_variant_type_is_tuple (type) &&
g_variant_type_n_items (type) == 2)
{
const GVariantType *first_type;
const GVariantType *second_type;
first_type = g_variant_type_first (type);
second_type = g_variant_type_next (first_type);
if (g_variant_type_is_basic (first_type) &&
!g_variant_type_equal (first_type, G_VARIANT_TYPE_BASIC) &&
g_variant_type_is_basic (second_type) &&
!g_variant_type_equal (second_type, G_VARIANT_TYPE_BASIC))
{
GConfValue *car;
GConfValue *cdr;
gconf_value = gconf_value_new (GCONF_VALUE_PAIR);
car = gconf_settings_backend_simple_gvariant_to_gconf_value (g_variant_get_child_value (value, 0), first_type);
cdr = gconf_settings_backend_simple_gvariant_to_gconf_value (g_variant_get_child_value (value, 1), second_type);
if (car)
gconf_value_set_car_nocopy (gconf_value, car);
if (cdr)
gconf_value_set_cdr_nocopy (gconf_value, cdr);
if (car == NULL || cdr == NULL)
{
gconf_value_free (gconf_value);
gconf_value = NULL;
}
}
}
return gconf_value;
}
/* Helper for utils_get_value, reads a list. The "list" is a struct with the
* list type and an array with the values directly in it.
*/
static GConfValue *
utils_get_value_helper_list (DBusMessageIter *iter)
{
DBusMessageIter struct_iter;
DBusMessageIter array_iter;
GConfValue *value;
gint32 list_type;
GSList *list;
GConfValue *child_value;
d(g_print ("Get value (list)\n"));
value = gconf_value_new (GCONF_VALUE_LIST);
dbus_message_iter_recurse (iter, &struct_iter);
/* Get the list type. */
dbus_message_iter_get_basic (&struct_iter, &list_type);
gconf_value_set_list_type (value, list_type);
/* Get the array. */
dbus_message_iter_next (&struct_iter);
dbus_message_iter_recurse (&struct_iter, &array_iter);
/* And the values from the array. */
list = NULL;
switch (list_type)
{
case GCONF_VALUE_STRING:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRING)
{
const gchar *str;
dbus_message_iter_get_basic (&array_iter, &str);
child_value = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (child_value, str);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_INT:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_INT32)
{
gint32 i;
dbus_message_iter_get_basic (&array_iter, &i);
child_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (child_value, i);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_FLOAT:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DOUBLE)
{
gdouble d;
dbus_message_iter_get_basic (&array_iter, &d);
child_value = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (child_value, d);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_BOOL:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_BOOLEAN)
{
gboolean b;
dbus_message_iter_get_basic (&array_iter, &b);
child_value = gconf_value_new (GCONF_VALUE_BOOL);
gconf_value_set_bool (child_value, b);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_SCHEMA:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRUCT)
{
child_value = utils_get_schema_value (&array_iter);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
default:
g_assert_not_reached ();
}
list = g_slist_reverse (list);
gconf_value_set_list_nocopy (value, list);
return value;
}
/* this actually works on any node,
not just <entry>, such as the <car>
and <cdr> nodes and the <li> nodes and the
<default> node
*/
static GConfValue*
node_extract_value(xmlNodePtr node, const gchar** locales, GError** err)
{
GConfValue* value = NULL;
gchar* type_str;
GConfValueType type = GCONF_VALUE_INVALID;
const gchar* default_locales[] = { "C", NULL };
if (locales == NULL)
locales = default_locales;
type_str = my_xmlGetProp(node, "type");
if (type_str == NULL)
{
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("No \"type\" attribute for <%s> node"),
(node->name ? (char*)node->name : "(nil)"));
return NULL;
}
type = gconf_value_type_from_string(type_str);
xmlFree(type_str);
switch (type)
{
case GCONF_VALUE_INVALID:
{
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("A node has unknown \"type\" attribute `%s', ignoring"), type_str);
return NULL;
}
break;
case GCONF_VALUE_INT:
case GCONF_VALUE_BOOL:
case GCONF_VALUE_FLOAT:
{
gchar* value_str;
value_str = my_xmlGetProp(node, "value");
if (value_str == NULL)
{
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("No \"value\" attribute for node"));
return NULL;
}
value = gconf_value_new_from_string(type, value_str, err);
xmlFree(value_str);
g_return_val_if_fail( (value != NULL) ||
(err == NULL) ||
(*err != NULL),
NULL );
return value;
}
break;
case GCONF_VALUE_STRING:
{
xmlNodePtr iter;
iter = node->xmlChildrenNode;
while (iter != NULL)
{
if (iter->type == XML_ELEMENT_NODE)
{
GConfValue* v = NULL;
if (strcmp((char *)iter->name, "stringvalue") == 0)
{
gchar* s;
s = (gchar *)xmlNodeGetContent(iter);
v = gconf_value_new(GCONF_VALUE_STRING);
/* strdup() caused purely by g_free()/free()
difference */
gconf_value_set_string(v, s ? s : "");
if (s)
xmlFree(s);
return v;
}
else
{
/* What the hell is this? */
gconf_log(GCL_WARNING,
_("Didn't understand XML node <%s> inside an XML list node"),
iter->name ? iter->name : (guchar*)"???");
}
}
iter = iter->next;
}
return NULL;
}
break;
case GCONF_VALUE_SCHEMA:
return schema_node_extract_value(node, locales);
break;
case GCONF_VALUE_LIST:
{
xmlNodePtr iter;
GSList* values = NULL;
GConfValueType list_type = GCONF_VALUE_INVALID;
{
gchar* s;
s = my_xmlGetProp(node, "ltype");
if (s != NULL)
{
list_type = gconf_value_type_from_string(s);
xmlFree(s);
}
}
switch (list_type)
{
case GCONF_VALUE_INVALID:
case GCONF_VALUE_LIST:
case GCONF_VALUE_PAIR:
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("Invalid type (list, pair, or unknown) in a list node"));
return NULL;
default:
break;
}
iter = node->xmlChildrenNode;
while (iter != NULL)
{
if (iter->type == XML_ELEMENT_NODE)
{
GConfValue* v = NULL;
if (strcmp((char*)iter->name, "li") == 0)
{
v = node_extract_value(iter, locales, err);
if (v == NULL)
{
if (err && *err)
{
gconf_log(GCL_WARNING,
_("Bad XML node: %s"),
(*err)->message);
/* avoid pile-ups */
g_clear_error(err);
}
}
else if (v->type != list_type)
{
gconf_log(GCL_WARNING, _("List contains a badly-typed node (%s, should be %s)"),
gconf_value_type_to_string(v->type),
gconf_value_type_to_string(list_type));
gconf_value_free(v);
v = NULL;
}
}
else
{
/* What the hell is this? */
gconf_log(GCL_WARNING,
_("Didn't understand XML node <%s> inside an XML list node"),
iter->name ? iter->name : (guchar*)"???");
}
if (v != NULL)
values = g_slist_prepend(values, v);
}
iter = iter->next;
}
/* put them in order, set the value */
values = g_slist_reverse(values);
value = gconf_value_new(GCONF_VALUE_LIST);
gconf_value_set_list_type(value, list_type);
gconf_value_set_list_nocopy(value, values);
return value;
}
break;
case GCONF_VALUE_PAIR:
{
GConfValue* car = NULL;
GConfValue* cdr = NULL;
xmlNodePtr iter;
iter = node->xmlChildrenNode;
while (iter != NULL)
{
if (iter->type == XML_ELEMENT_NODE)
{
if (car == NULL && strcmp((char *)iter->name, "car") == 0)
{
car = node_extract_value(iter, locales, err);
if (car == NULL)
{
if (err && *err)
{
gconf_log(GCL_WARNING,
_("Ignoring bad car from XML pair: %s"),
(*err)->message);
/* prevent pile-ups */
g_clear_error(err);
}
}
else if (car->type == GCONF_VALUE_LIST ||
car->type == GCONF_VALUE_PAIR)
{
gconf_log(GCL_WARNING, _("parsing XML file: lists and pairs may not be placed inside a pair"));
gconf_value_free(car);
car = NULL;
}
}
else if (cdr == NULL && strcmp((char *)iter->name, "cdr") == 0)
{
cdr = node_extract_value(iter, locales, err);
if (cdr == NULL)
{
if (err && *err)
{
gconf_log(GCL_WARNING,
_("Ignoring bad cdr from XML pair: %s"),
(*err)->message);
/* avoid pile-ups */
g_clear_error(err);
}
}
else if (cdr->type == GCONF_VALUE_LIST ||
cdr->type == GCONF_VALUE_PAIR)
{
gconf_log(GCL_WARNING,
_("parsing XML file: lists and pairs may not be placed inside a pair"));
gconf_value_free(cdr);
cdr = NULL;
}
}
else
{
/* What the hell is this? */
gconf_log(GCL_WARNING,
_("Didn't understand XML node <%s> inside an XML pair node"),
iter->name ? (gchar*)iter->name : "???");
}
}
iter = iter->next;
}
/* Return the pair if we got both halves */
if (car && cdr)
{
value = gconf_value_new(GCONF_VALUE_PAIR);
gconf_value_set_car_nocopy(value, car);
gconf_value_set_cdr_nocopy(value, cdr);
return value;
}
else
{
gconf_log(GCL_WARNING, _("Didn't find car and cdr for XML pair node"));
if (car)
{
g_assert(cdr == NULL);
gconf_value_free(car);
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("Missing cdr from pair of values in XML file"));
}
else if (cdr)
{
g_assert(car == NULL);
gconf_value_free(cdr);
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("Missing car from pair of values in XML file"));
}
else
{
gconf_set_error(err, GCONF_ERROR_PARSE_ERROR,
_("Missing both car and cdr values from pair in XML file"));
}
return NULL;
}
}
break;
default:
g_assert_not_reached();
return NULL;
break;
}
}
