/* 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");
}
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);
}
void*
nsvn_gconf_read_config_entry (const char *key,
const char *schema,
GConfClient *gcc)
{
GConfSchema *gcs;
GConfValueType gct;
GError *err=NULL;
void *ret=NULL;
gboolean *bval = NULL;
if (gcc == NULL || key == NULL)
return NULL;
/* Check for the presense of schema, if not return fail. */
/* Get key details from schema. */
/* Check for the presense of dir, if not create it. */
/* if already present update it with new value. */
gcs = gconf_client_get_schema (gcc, schema, &err);
if (!gcs) return NULL;
gct = gconf_schema_get_type (gcs);
switch (gct)
{
case GCONF_VALUE_STRING:
ret = (void*) gconf_client_get_string (gcc, key, &err);
break;
case GCONF_VALUE_INT:
break;
case GCONF_VALUE_FLOAT:
break;
case GCONF_VALUE_BOOL:
bval = (gboolean*)g_malloc0(sizeof(gboolean));
*bval = gconf_client_get_bool (gcc, key, &err);
ret = (void*)bval;
break;
case GCONF_VALUE_LIST:
break;
case GCONF_VALUE_PAIR:
break;
default:
break;
}
return ret;
}
int
nsvn_gconf_write_config_entry (const char *key,
const char *schema,
void *value,
GConfClient *gcc)
{
GConfSchema *gcs;
GConfValueType gct;
if (gcc == NULL || key == NULL)
return 0;
/* Check for the presense of schema, if not return fail. */
/* Get key details from schema. */
/* Check for the presense of dir, if not create it. */
/* if already present update it with new value. */
gcs = gconf_client_get_schema (gcc, schema, NULL);
if (!gcs) return TRUE;
gct = gconf_schema_get_type (gcs);
switch (gct)
{
case GCONF_VALUE_STRING:
gconf_client_set_string (gcc, key, (const char*)value, NULL);
break;
case GCONF_VALUE_INT:
break;
case GCONF_VALUE_FLOAT:
break;
case GCONF_VALUE_BOOL:
gconf_client_set_bool (gcc, key, *((gboolean*)value), NULL);
break;
case GCONF_VALUE_LIST:
break;
case GCONF_VALUE_PAIR:
break;
default:
break;
}
return 1;
}
static void gconf_dialog_onResetButtonPressed (GConfDialog* self, GtkButton* widget) {
GConfSchema* schema;
GConfValue* default_value;
GtkWidget* target;
g_return_if_fail (self != NULL);
g_return_if_fail (widget != NULL);
schema = (GConfSchema*) g_object_get_data ((GObject*) widget, "gconf-schema");
default_value = gconf_schema_get_default_value (schema);
target = _g_object_ref0 ((GtkWidget*) g_object_get_data ((GObject*) widget, "target"));
switch (gconf_schema_get_type (schema)) {
case GCONF_VALUE_BOOL:
{
GtkWidget* _tmp0_;
GtkCheckButton* checkbutton;
checkbutton = _g_object_ref0 ((_tmp0_ = target, GTK_IS_CHECK_BUTTON (_tmp0_) ? ((GtkCheckButton*) _tmp0_) : NULL));
gtk_toggle_button_set_active ((GtkToggleButton*) checkbutton, gconf_value_get_bool (default_value));
_g_object_unref0 (checkbutton);
break;
}
case GCONF_VALUE_STRING:
{
GtkWidget* _tmp1_;
GtkEntry* entrybox;
entrybox = _g_object_ref0 ((_tmp1_ = target, GTK_IS_ENTRY (_tmp1_) ? ((GtkEntry*) _tmp1_) : NULL));
gtk_entry_set_text (entrybox, gconf_value_get_string (default_value));
_g_object_unref0 (entrybox);
break;
}
case GCONF_VALUE_INT:
{
GtkWidget* _tmp2_;
GtkSpinButton* spin;
spin = _g_object_ref0 ((_tmp2_ = target, GTK_IS_SPIN_BUTTON (_tmp2_) ? ((GtkSpinButton*) _tmp2_) : NULL));
gtk_spin_button_set_value (spin, (double) gconf_value_get_int (default_value));
_g_object_unref0 (spin);
break;
}
}
_g_object_unref0 (target);
}
static GtkWidget* gconf_dialog_create_proxy_widget (GConfDialog* self, const char* key, GError** error) {
GtkWidget* result = NULL;
GError * _inner_error_;
GConfEntry* entry;
GConfSchema* schema;
const char* tooltip;
GtkBox* row;
GtkLabel* label;
GtkWidget* action_widget;
GtkWidget* render_widget;
GConfEntry* _tmp10_;
GtkButton* reset;
GConfEntry* _tmp11_;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (key != NULL, NULL);
_inner_error_ = NULL;
entry = gconf_client_get_entry (self->priv->_default_client, key, NULL, TRUE, &_inner_error_);
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
return NULL;
}
schema = gconf_dialog_safely_get_schema (self, entry);
tooltip = gconf_schema_get_long_desc (schema);
row = (GtkBox*) g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0));
label = g_object_ref_sink ((GtkLabel*) gtk_label_new (gconf_schema_get_short_desc (schema)));
gtk_label_set_justify (label, GTK_JUSTIFY_LEFT);
gtk_widget_set_tooltip_text ((GtkWidget*) label, tooltip);
action_widget = NULL;
render_widget = NULL;
switch (gconf_schema_get_type (schema)) {
case GCONF_VALUE_BOOL:
{
GtkCheckButton* checkbox;
gboolean _tmp0_;
GtkWidget* _tmp1_;
GtkWidget* _tmp2_;
checkbox = g_object_ref_sink ((GtkCheckButton*) gtk_check_button_new ());
_tmp0_ = gconf_client_get_bool (self->priv->_default_client, entry->key, &_inner_error_);
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (checkbox);
_g_object_unref0 (render_widget);
_g_object_unref0 (action_widget);
_g_object_unref0 (label);
_g_object_unref0 (row);
_gconf_schema_free0 (schema);
_gconf_entry_unref0 (entry);
return NULL;
}
gtk_toggle_button_set_active ((GtkToggleButton*) checkbox, _tmp0_);
g_signal_connect_object ((GtkButton*) checkbox, "clicked", (GCallback) _gconf_dialog_onCheckButtonActivated_gtk_button_clicked, self, 0);
gtk_container_add ((GtkContainer*) checkbox, (GtkWidget*) label);
render_widget = (_tmp1_ = _g_object_ref0 ((GtkWidget*) checkbox), _g_object_unref0 (render_widget), _tmp1_);
action_widget = (_tmp2_ = _g_object_ref0 (render_widget), _g_object_unref0 (action_widget), _tmp2_);
_g_object_unref0 (checkbox);
break;
}
case GCONF_VALUE_STRING:
{
GtkEntry* entrybox;
GtkHBox* box;
char* _tmp3_;
char* _tmp4_;
GtkWidget* _tmp5_;
GtkWidget* _tmp6_;
entrybox = g_object_ref_sink ((GtkEntry*) gtk_entry_new ());
box = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0));
_tmp3_ = gconf_client_get_string (self->priv->_default_client, entry->key, &_inner_error_);
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (box);
_g_object_unref0 (entrybox);
_g_object_unref0 (render_widget);
_g_object_unref0 (action_widget);
_g_object_unref0 (label);
_g_object_unref0 (row);
_gconf_schema_free0 (schema);
_gconf_entry_unref0 (entry);
return NULL;
}
gtk_entry_set_text (entrybox, _tmp4_ = _tmp3_);
_g_free0 (_tmp4_);
gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) label, FALSE, FALSE, (guint) 2);
gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) entrybox, FALSE, FALSE, (guint) 2);
action_widget = (_tmp5_ = _g_object_ref0 ((GtkWidget*) entrybox), _g_object_unref0 (action_widget), _tmp5_);
render_widget = (_tmp6_ = _g_object_ref0 ((GtkWidget*) box), _g_object_unref0 (render_widget), _tmp6_);
_g_object_unref0 (box);
_g_object_unref0 (entrybox);
break;
}
case GCONF_VALUE_INT:
{
GtkHBox* box;
GtkSpinButton* spin;
gint _tmp7_;
GtkWidget* _tmp8_;
GtkWidget* _tmp9_;
box = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0));
spin = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) (-100), (double) 200, (double) 1));
_tmp7_ = gconf_client_get_int (self->priv->_default_client, entry->key, &_inner_error_);
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (spin);
_g_object_unref0 (box);
_g_object_unref0 (render_widget);
_g_object_unref0 (action_widget);
_g_object_unref0 (label);
_g_object_unref0 (row);
_gconf_schema_free0 (schema);
_gconf_entry_unref0 (entry);
return NULL;
}
gtk_spin_button_set_value (spin, (double) _tmp7_);
g_signal_connect_object (spin, "value-changed", (GCallback) _gconf_dialog_onSpinButtonValueChanged_gtk_spin_button_value_changed, self, 0);
gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) label, FALSE, FALSE, (guint) 2);
gtk_box_pack_start ((GtkBox*) box, (GtkWidget*) spin, FALSE, FALSE, (guint) 2);
action_widget = (_tmp8_ = _g_object_ref0 ((GtkWidget*) spin), _g_object_unref0 (action_widget), _tmp8_);
render_widget = (_tmp9_ = _g_object_ref0 ((GtkWidget*) box), _g_object_unref0 (render_widget), _tmp9_);
_g_object_unref0 (spin);
_g_object_unref0 (box);
break;
}
default:
{
result = (GtkWidget*) g_object_ref_sink ((GtkEventBox*) gtk_event_box_new ());
_g_object_unref0 (render_widget);
_g_object_unref0 (action_widget);
_g_object_unref0 (label);
_g_object_unref0 (row);
_gconf_schema_free0 (schema);
_gconf_entry_unref0 (entry);
return result;
}
}
gtk_widget_set_tooltip_text (action_widget, tooltip);
g_object_set_data_full ((GObject*) action_widget, "gconf-entry", (_tmp10_ = entry, (_tmp10_ == NULL) ? NULL : gconf_entry_ref (_tmp10_), _tmp10_), gconf_entry_unref);
g_object_set_data_full ((GObject*) action_widget, "gconf-schema", gconf_schema_copy (schema), gconf_schema_free);
reset = g_object_ref_sink ((GtkButton*) gtk_button_new_from_stock (GTK_STOCK_CLEAR));
gtk_widget_set_tooltip_text ((GtkWidget*) reset, _ ("Reset to the default value"));
g_object_set_data_full ((GObject*) reset, "gconf-entry", (_tmp11_ = entry, (_tmp11_ == NULL) ? NULL : gconf_entry_ref (_tmp11_), _tmp11_), gconf_entry_unref);
g_object_set_data_full ((GObject*) reset, "gconf-schema", gconf_schema_copy (schema), gconf_schema_free);
g_object_set_data_full ((GObject*) reset, "target", _g_object_ref0 (action_widget), g_object_unref);
g_signal_connect_object (reset, "clicked", (GCallback) _gconf_dialog_onResetButtonPressed_gtk_button_clicked, self, 0);
gtk_box_pack_start (row, render_widget, FALSE, FALSE, (guint) 2);
gtk_box_pack_end (row, (GtkWidget*) reset, FALSE, FALSE, (guint) 2);
result = (GtkWidget*) row;
_g_object_unref0 (reset);
_g_object_unref0 (render_widget);
_g_object_unref0 (action_widget);
_g_object_unref0 (label);
_gconf_schema_free0 (schema);
_gconf_entry_unref0 (entry);
return result;
}
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));
}
}
