/* 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; }
/* 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; } }