static gboolean
simple_value_is_equal (const GConfValue *a,
const GConfValue *b)
{
g_assert (a != NULL);
g_assert (b != NULL);
switch (a->type) {
case GCONF_VALUE_STRING:
return eel_str_is_equal (gconf_value_get_string (a),
gconf_value_get_string (b));
case GCONF_VALUE_INT:
return gconf_value_get_int (a) ==
gconf_value_get_int (b);
case GCONF_VALUE_FLOAT:
return gconf_value_get_float (a) ==
gconf_value_get_float (b);
case GCONF_VALUE_BOOL:
return gconf_value_get_bool (a) ==
gconf_value_get_bool (b);
default:
g_assert_not_reached ();
}
return FALSE;
}
static GConfValue *
motion_acceleration_from_gconf (GConfPropertyEditor *peditor,
const GConfValue *value)
{
GConfValue *new_value;
gfloat motion_acceleration;
new_value = gconf_value_new (GCONF_VALUE_FLOAT);
if (gconf_value_get_float (value) == -1.0) {
int numerator, denominator;
get_default_mouse_info (&numerator, &denominator, NULL);
motion_acceleration = CLAMP ((gfloat)(numerator / denominator), 0.2, 6.0);
}
else {
motion_acceleration = CLAMP (gconf_value_get_float (value), 0.2, 6.0);
}
if (motion_acceleration >= 1)
gconf_value_set_float (new_value, motion_acceleration + 4);
else
gconf_value_set_float (new_value, motion_acceleration * 5);
return new_value;
}
static void getagpslatlon()
{
GConfClient *clint = NULL;
double d;
char c[100];
GConfValue *gcv = NULL;
g_type_init();
strcpy(c, "/system/osso/supl/");
strcat(c, "pos_latitude");
clint = gconf_client_get_default();
gcv = gconf_client_get_without_default(clint, c, NULL);
d = 0.0;
if (gcv) {
d = gconf_value_get_float(gcv);
gconf_value_free(gcv);
}
g_object_unref(clint);
gpst.llat = (int) (d * 1000000.0);
strcpy(c, "/system/osso/supl/");
strcat(c, "pos_longitude");
clint = gconf_client_get_default();
gcv = gconf_client_get_without_default(clint, c, NULL);
d = 0.0;
if (gcv) {
d = gconf_value_get_float(gcv);
gconf_value_free(gcv);
}
g_object_unref(clint);
gpst.llon = (int) (d * 1000000.0);
}
static void
gconf_value_changed (GConfClient *client,
const gchar *key,
GConfValue *value,
gpointer data)
{
MTClosure *mt = data;
if (g_str_equal (key, OPT_THRESHOLD) && value->type == GCONF_VALUE_INT)
mt->threshold = gconf_value_get_int (value);
else if (g_str_equal (key, OPT_DELAY) && value->type == GCONF_VALUE_BOOL)
mt->delay_enabled = gconf_value_get_bool (value);
else if (g_str_equal (key, OPT_DELAY_T) && value->type == GCONF_VALUE_FLOAT)
mt_timer_set_target (mt->delay_timer, gconf_value_get_float (value));
else if (g_str_equal (key, OPT_DWELL) && value->type == GCONF_VALUE_BOOL) {
mt->dwell_enabled = gconf_value_get_bool (value);
mt_ctw_update_sensitivity (mt);
mt_ctw_update_visibility (mt);
}
else if (g_str_equal (key, OPT_DWELL_T) && value->type == GCONF_VALUE_FLOAT)
mt_timer_set_target (mt->dwell_timer, gconf_value_get_float (value));
else if (g_str_equal (key, OPT_CTW) && value->type == GCONF_VALUE_BOOL) {
mt->dwell_show_ctw = gconf_value_get_bool (value);
mt_ctw_update_visibility (mt);
}
else if (g_str_equal (key, OPT_MODE) && value->type == GCONF_VALUE_INT) {
mt->dwell_mode = gconf_value_get_int (value);
mt_ctw_update_sensitivity (mt);
}
else if (g_str_equal (key, OPT_STYLE) && value->type == GCONF_VALUE_INT) {
mt->style = gconf_value_get_int (value);
mt_ctw_update_style (mt, mt->style);
}
else if (g_str_equal (key, OPT_G_SINGLE) && value->type == GCONF_VALUE_INT)
mt->dwell_dirs[DWELL_CLICK_TYPE_SINGLE] = gconf_value_get_int (value);
else if (g_str_equal (key, OPT_G_DOUBLE) && value->type == GCONF_VALUE_INT)
mt->dwell_dirs[DWELL_CLICK_TYPE_DOUBLE] = gconf_value_get_int (value);
else if (g_str_equal (key, OPT_G_DRAG) && value->type == GCONF_VALUE_INT)
mt->dwell_dirs[DWELL_CLICK_TYPE_DRAG] = gconf_value_get_int (value);
else if (g_str_equal (key, OPT_G_RIGHT) && value->type == GCONF_VALUE_INT)
mt->dwell_dirs[DWELL_CLICK_TYPE_RIGHT] = gconf_value_get_int (value);
else if (g_str_equal (key, OPT_ANIMATE) && value->type == GCONF_VALUE_BOOL) {
MtCursorManager *manager;
manager = mt_cursor_manager_get_default ();
mt->animate_cursor = gconf_value_get_bool (value);
if (mt->animate_cursor)
mt->cursor = mt_cursor_manager_current_cursor (manager);
else
mt_cursor_manager_restore_all (manager);
}
}
/** 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;
}
float
confsection_t::get_float(const char *name, float deflt)
{
float val;
string_var key = make_key(name);
#if HAVE_LIBGCONF
GError *e = 0;
GConfValue *gcv = gconf_client_get(gconf_client_get_default(), key, &e);
handle_error(secname_, e);
if (gcv == 0)
{
val = deflt;
}
else
{
val = gconf_value_get_float(gcv);
gconf_value_free(gcv);
}
#else
gboolean defaulted = FALSE;
val = gnome_config_get_float_with_default(key.data(), &defaulted);
if (defaulted)
val = deflt;
#endif
return val;
}
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;
}
}
gboolean
gpds_gconf_get_float (GConfClient *gconf, const gchar *key, gdouble *value)
{
GConfValue *gconf_value;
gboolean exist_value = FALSE;
gconf_value = gconf_client_get(gconf, key, NULL);
if (gconf_value) {
if (gconf_value->type == GCONF_VALUE_FLOAT) {
*value = gconf_value_get_float(gconf_value);
exist_value = TRUE;
}
gconf_value_free(gconf_value);
}
return exist_value;
}
static GConfValue *
motion_acceleration_to_gconf (GConfPropertyEditor *peditor,
const GConfValue *value)
{
GConfValue *new_value;
gfloat motion_acceleration;
new_value = gconf_value_new (GCONF_VALUE_FLOAT);
motion_acceleration = CLAMP (gconf_value_get_float (value), 1.0, 10.0);
if (motion_acceleration < 5)
gconf_value_set_float (new_value, motion_acceleration / 5.0);
else
gconf_value_set_float (new_value, motion_acceleration - 4);
return new_value;
}
static void
_gconf_ratio_notify_cb (GConfClient *client,
guint cnxn_id,
GConfEntry *entry,
gpointer userdata)
{
PengeEverythingPane *pane = PENGE_EVERYTHING_PANE (userdata);
PengeEverythingPanePrivate *priv = GET_PRIVATE (pane);
GConfValue *value;
value = gconf_entry_get_value (entry);
if (!value)
priv->ratio = 0.5;
else
priv->ratio = gconf_value_get_float (value);
penge_everything_pane_queue_update (pane);
}
SCM
gconf_value_to_scm(GConfValue* val)
{
SCM retval = SCM_EOL;
if (val == NULL)
return SCM_EOL;
switch (val->type)
{
case GCONF_VALUE_INVALID:
/* EOL */
break;
case GCONF_VALUE_STRING:
retval = gh_str02scm(gconf_value_get_string(val));
break;
case GCONF_VALUE_INT:
retval = gh_int2scm(gconf_value_get_int(val));
break;
case GCONF_VALUE_FLOAT:
retval = gh_double2scm(gconf_value_get_float(val));
break;
case GCONF_VALUE_BOOL:
retval = gh_bool2scm(gconf_value_get_bool(val));
break;
case GCONF_VALUE_SCHEMA:
/* FIXME this is more complicated, we need a smob or something */
break;
case GCONF_VALUE_LIST:
/* FIXME This is complicated too... */
break;
case GCONF_VALUE_PAIR:
retval = gh_cons(gconf_value_to_scm(gconf_value_get_car(val)),
gconf_value_to_scm(gconf_value_get_cdr(val)));
break;
default:
g_warning("Unhandled type in %s", G_STRFUNC);
break;
}
return retval;
}
/* Helper for utils_append_value, writes a int/string/float/bool/schema.
*/
static void
utils_append_value_helper_fundamental (DBusMessageIter *iter,
const GConfValue *value)
{
gint32 i;
gboolean b;
const gchar *s;
gdouble d;
d(g_print ("Append value (fundamental)\n"));
switch (value->type)
{
case GCONF_VALUE_INT:
i = gconf_value_get_int (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &i);
break;
case GCONF_VALUE_STRING:
s = gconf_value_get_string (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &s);
break;
case GCONF_VALUE_FLOAT:
d = gconf_value_get_float (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &d);
break;
case GCONF_VALUE_BOOL:
b = gconf_value_get_bool (value);
dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &b);
break;
case GCONF_VALUE_SCHEMA:
utils_append_schema (iter, gconf_value_get_schema (value));
break;
default:
g_assert_not_reached ();
}
}
/* Callback invoked when equalizer values change in gconf. Updates sliders
* accordingly */
static void update_slider_cb(GConfClient *client,
guint cnxn_id,
GConfEntry *entry,
GtkWidget *slider_band[NUM_BANDS])
{
const gchar *key;
GConfValue *value;
gdouble gain;
gint band_number;
key = gconf_entry_get_key(entry);
value = gconf_entry_get_value(entry);
/* Get band number */
sscanf (key, GCONF_MAFW_GST_EQ_RENDERER "/band%d", &band_number);
if (band_number < NUM_BANDS) {
gain = value?
CLAMP(gconf_value_get_float(value), -24.0, +12.0): 0.0;
gtk_range_set_value(GTK_RANGE(slider_band[band_number]), gain);
}
}
/*
* The font rendering details dialog
*/
static void
dpi_load (GConfClient *client,
GtkSpinButton *spinner)
{
GConfValue *value;
gdouble dpi;
value = gconf_client_get_without_default (client, FONT_DPI_KEY, NULL);
if (value) {
dpi = gconf_value_get_float (value);
gconf_value_free (value);
} else
dpi = get_dpi_from_x_server ();
if (dpi < DPI_LOW_REASONABLE_VALUE)
dpi = DPI_LOW_REASONABLE_VALUE;
in_change = TRUE;
gtk_spin_button_set_value (spinner, dpi);
in_change = FALSE;
}
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();
}
}
}
/** Helper for appending GConfValue to dbus message
*
* @param reply DBusMessage under construction
* @param conf GConfValue to be added to the reply
*
* @return TRUE if the value was succesfully appended, or FALSE on failure
*/
static gboolean append_gconf_value_to_dbus_message(DBusMessage *reply, GConfValue *conf)
{
const char *sig = 0;
DBusMessageIter body, variant, array;
if( !(sig = value_signature(conf)) ) {
goto bailout_message;
}
dbus_message_iter_init_append(reply, &body);
if( !dbus_message_iter_open_container(&body, DBUS_TYPE_VARIANT,
sig, &variant) ) {
goto bailout_message;
}
switch( conf->type ) {
case GCONF_VALUE_STRING:
{
const char *arg = gconf_value_get_string(conf) ?: "";
dbus_message_iter_append_basic(&variant,
DBUS_TYPE_STRING,
&arg);
}
break;
case GCONF_VALUE_INT:
{
dbus_int32_t arg = gconf_value_get_int(conf);
dbus_message_iter_append_basic(&variant,
DBUS_TYPE_INT32,
&arg);
}
break;
case GCONF_VALUE_FLOAT:
{
double arg = gconf_value_get_float(conf);
dbus_message_iter_append_basic(&variant,
DBUS_TYPE_DOUBLE,
&arg);
}
break;
case GCONF_VALUE_BOOL:
{
dbus_bool_t arg = gconf_value_get_bool(conf);
dbus_message_iter_append_basic(&variant,
DBUS_TYPE_BOOLEAN,
&arg);
}
break;
case GCONF_VALUE_LIST:
if( !(sig = type_signature(gconf_value_get_list_type(conf))) ) {
goto bailout_variant;
}
if( !dbus_message_iter_open_container(&variant,
DBUS_TYPE_ARRAY,
sig, &array) ) {
goto bailout_variant;
}
switch( gconf_value_get_list_type(conf) ) {
case GCONF_VALUE_STRING:
{
int cnt = 0;
const char **arg = string_array_from_gconf_value(conf, &cnt);
for( int i = 0; i < cnt; ++i ) {
const char *str = arg[i];
dbus_message_iter_append_basic(&array,
DBUS_TYPE_STRING,
&str);
}
g_free(arg);
}
break;
case GCONF_VALUE_INT:
{
int cnt = 0;
dbus_int32_t *arg = int_array_from_gconf_value(conf, &cnt);
dbus_message_iter_append_fixed_array(&array,
DBUS_TYPE_INT32,
&arg, cnt);
g_free(arg);
}
break;
case GCONF_VALUE_FLOAT:
{
int cnt = 0;
double *arg = float_array_from_gconf_value(conf, &cnt);
dbus_message_iter_append_fixed_array(&array,
DBUS_TYPE_DOUBLE,
&arg, cnt);
g_free(arg);
}
break;
case GCONF_VALUE_BOOL:
{
int cnt = 0;
dbus_bool_t *arg = bool_array_from_gconf_value(conf, &cnt);
dbus_message_iter_append_fixed_array(&array,
DBUS_TYPE_BOOLEAN,
&arg, cnt);
g_free(arg);
}
break;
default:
goto bailout_array;
}
if( !dbus_message_iter_close_container(&variant, &array) ) {
goto bailout_variant;
}
break;
default:
goto bailout_variant;
}
if( !dbus_message_iter_close_container(&body, &variant) ) {
goto bailout_message;
}
return TRUE;
bailout_array:
dbus_message_iter_abandon_container(&variant, &array);
bailout_variant:
dbus_message_iter_abandon_container(&body, &variant);
bailout_message:
return FALSE;
}
static GVariant *
gconf_settings_backend_simple_gconf_value_type_to_gvariant (GConfValue *gconf_value,
const GVariantType *expected_type)
{
/* Note: it's guaranteed that the types are compatible */
GVariant *variant = NULL;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
variant = g_variant_new_boolean (gconf_value_get_bool (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0 || value > 255)
return NULL;
variant = g_variant_new_byte (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
int value = gconf_value_get_int (gconf_value);
if (value < G_MINSHORT || value > G_MAXSHORT)
return NULL;
variant = g_variant_new_int16 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0 || value > G_MAXUSHORT)
return NULL;
variant = g_variant_new_uint16 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
variant = g_variant_new_int32 (gconf_value_get_int (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_uint32 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
variant = g_variant_new_int64 ((gint64) gconf_value_get_int (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_uint64 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_handle (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double (gconf_value_get_float (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
variant = g_variant_new_string (gconf_value_get_string (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
variant = g_variant_new_object_path (gconf_value_get_string (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
variant = g_variant_new_signature (gconf_value_get_string (gconf_value));
return variant;
}
/* 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);
}
/* Syncs a value from GConf to an object property */
static void
prop_binding_sync_pref_to_prop (PropBinding *binding,
GConfValue *pref_value)
{
GValue src_value, value;
/* Make sure we don't enter an infinite synchronizing loop */
g_signal_handler_block (binding->object, binding->prop_notify_id);
memset (&src_value, 0, sizeof (GValue));
/* First, convert GConfValue to GValue */
switch (pref_value->type) {
case GCONF_VALUE_STRING:
g_value_init (&src_value, G_TYPE_STRING);
g_value_set_string (&src_value,
gconf_value_get_string (pref_value));
break;
case GCONF_VALUE_INT:
g_value_init (&src_value, G_TYPE_INT);
g_value_set_int (&src_value,
gconf_value_get_int (pref_value));
break;
case GCONF_VALUE_BOOL:
g_value_init (&src_value, G_TYPE_BOOLEAN);
g_value_set_boolean (&src_value,
gconf_value_get_bool (pref_value));
break;
case GCONF_VALUE_FLOAT:
g_value_init (&src_value, G_TYPE_FLOAT);
g_value_set_float (&src_value,
gconf_value_get_float (pref_value));
break;
default:
g_warning ("prop_binding_sync_pref_to_prop: Unhandled value "
"type '%d'.\n", pref_value->type);
return;
}
/* Then convert to the type expected by the object, if necessary */
memset (&value, 0, sizeof (GValue));
g_value_init (&value,
G_PARAM_SPEC_VALUE_TYPE (binding->prop));
if (src_value.g_type != value.g_type) {
if (!g_value_transform (&src_value, &value)) {
g_warning ("prop_binding_sync_pref_to_prop: Failed to "
"transform a \"%s\" to a \"%s\".",
g_type_name (src_value.g_type),
g_type_name (value.g_type));
goto done;
}
g_object_set_property (binding->object,
binding->prop->name, &value);
} else {
g_object_set_property (binding->object,
binding->prop->name, &src_value);
}
done:
g_value_unset (&src_value);
g_value_unset (&value);
g_signal_handler_unblock (binding->object, binding->prop_notify_id);
}
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;
}
