git.maemo.org Git - modest/blob - src/modest-conf-gconf.c

   1 /* modest-conf-gconf.c */
   2 /* GConf implementation of ModestConf */
   3
   4 /* insert (c)/licensing information) */
   5
   6 #include "modest-conf.h"
   7 #include "modest-marshal.h"
   8 #include <gconf/gconf-client.h>
   9
  10
  11 /* 'private'/'protected' functions */
  12 static void   modest_conf_class_init     (ModestConfClass *klass);
  13 static void   modest_conf_init           (ModestConf *obj);
  14 static void   modest_conf_finalize       (GObject *obj);
  15
  16 static void   modest_conf_on_change      (GConfClient *client, guint conn_id,
  17                                           GConfEntry *entry, gpointer data);
  18 /* list my signals */
  19 enum {
  20         KEY_CHANGED_SIGNAL,
  21         LAST_SIGNAL
  22 };
  23
  24 typedef struct _ModestConfPrivate ModestConfPrivate;
  25 struct _ModestConfPrivate {
  26         GConfClient *gconf_client;
  27 };
  28 #define MODEST_CONF_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  29                                          MODEST_TYPE_CONF, \
  30                                          ModestConfPrivate))
  31 /* globals */
  32 static GObjectClass *parent_class = NULL;
  33
  34 static guint signals[LAST_SIGNAL] = {0};
  35
  36 void
  37 modest_conf_key_changed (ModestConf* self, const gchar *key, const gchar *new_value)
  38 {
  39         g_signal_emit (self, signals[KEY_CHANGED_SIGNAL], 0, key, new_value);
  40 }
  41
  42
  43 GType
  44 modest_conf_get_type (void)
  45 {
  46         static GType my_type = 0;
  47         if (!my_type) {
  48                 static const GTypeInfo my_info = {
  49                         sizeof(ModestConfClass),
  50                         NULL,           /* base init */
  51                         NULL,           /* base finalize */
  52                         (GClassInitFunc) modest_conf_class_init,
  53                         NULL,           /* class finalize */
  54                         NULL,           /* class data */
  55                         sizeof(ModestConf),
  56                         1,              /* n_preallocs */
  57                         (GInstanceInitFunc) modest_conf_init,
  58                 };
  59                 my_type = g_type_register_static (G_TYPE_OBJECT,
  60                                                   "ModestConf",
  61                                                   &my_info, 0);
  62         }
  63         return my_type;
  64 }
  65
  66 static void
  67 modest_conf_class_init (ModestConfClass *klass)
  68 {
  69         GObjectClass *gobject_class;
  70         gobject_class = (GObjectClass*) klass;
  71         GType paramtypes[2] = {G_TYPE_POINTER, G_TYPE_POINTER};
  72
  73         parent_class            = g_type_class_peek_parent (klass);
  74         gobject_class->finalize = modest_conf_finalize;
  75
  76         g_type_class_add_private (gobject_class, sizeof(ModestConfPrivate));
  77
  78         klass->key_changed = modest_conf_key_changed;
  79
  80         signals[KEY_CHANGED_SIGNAL] =
  81                 g_signal_newv ("key-changed",
  82                                G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_LAST,
  83                                NULL, NULL, NULL,
  84                                modest_marshal_VOID__POINTER_POINTER,
  85                                G_TYPE_NONE, 2, paramtypes);
  86 }
  87
  88 static void
  89 modest_conf_init (ModestConf *obj)
  90 {
  91         GConfClient *conf = NULL;
  92         ModestConfPrivate *priv = MODEST_CONF_GET_PRIVATE(obj);
  93         GError *err      = NULL;
  94
  95         priv->gconf_client = NULL;
  96
  97         conf = gconf_client_get_default ();
  98         if (!conf) {
  99                 g_warning ("could not get gconf client");
 100                 return;
 101         }
 102
 103         /* FIXME: is PRELOAD_NONE the most efficient? */
 104         gconf_client_add_dir (conf, MODEST_CONF_NAMESPACE,
 105                               GCONF_CLIENT_PRELOAD_NONE, &err);
 106         if (err) {
 107                 g_warning ("error with gconf_client_add_dir: %d:%s",
 108                            err->code, err->message);
 109                 g_object_unref (conf);
 110                 g_error_free (err);
 111                 return;
 112         }
 113
 114         gconf_client_notify_add (conf, MODEST_CONF_NAMESPACE,
 115                                  modest_conf_on_change,
 116                                  obj, NULL, &err);
 117         if (err) {
 118                 g_warning ("error with gconf_client_notify_add: %d:%s",
 119                            err->code, err->message);
 120                 g_object_unref (conf);
 121                 g_error_free (err);
 122                 return;
 123         }
 124
 125         /* all went well! */
 126         priv->gconf_client = conf;
 127         return;
 128 }
 129
 130 static void
 131 modest_conf_finalize (GObject *obj)
 132 {
 133         ModestConfPrivate *priv = MODEST_CONF_GET_PRIVATE(obj);
 134         if (priv->gconf_client) {
 135                 gconf_client_suggest_sync (priv->gconf_client, NULL);
 136                 g_object_unref (priv->gconf_client);
 137         }
 138 }
 139
 140 GObject*
 141 modest_conf_new (void)
 142 {
 143         ModestConf *conf = MODEST_CONF(g_object_new(MODEST_TYPE_CONF, NULL));
 144         if (!conf) {
 145                 g_warning ("failed to init ModestConf (GConf)");
 146                 return NULL;
 147         }
 148
 149         ModestConfPrivate *priv = MODEST_CONF_GET_PRIVATE(conf);
 150         if (!priv->gconf_client) {
 151                 g_warning ("failed to init gconf");
 152                 g_object_unref (conf);
 153                 return NULL;
 154         }
 155
 156         return G_OBJECT(conf);
 157 }
 158
 159
 160 gchar*
 161 modest_conf_get_string (ModestConf* self, const gchar* key, GError **err)
 162 {
 163         ModestConfPrivate *priv;
 164
 165         g_return_val_if_fail (self, NULL);
 166         g_return_val_if_fail (key,  NULL);
 167
 168         priv = MODEST_CONF_GET_PRIVATE(self);
 169         return gconf_client_get_string (priv->gconf_client, key, err);
 170 }
 171
 172
 173 gint
 174 modest_conf_get_int (ModestConf* self, const gchar* key, GError **err)
 175 {
 176         ModestConfPrivate *priv;
 177
 178         g_return_val_if_fail (self, -1);
 179         g_return_val_if_fail (key, -1);
 180
 181         priv = MODEST_CONF_GET_PRIVATE(self);
 182
 183         return gconf_client_get_int (priv->gconf_client, key, err);
 184 }
 185
 186
 187 gboolean
 188 modest_conf_get_bool (ModestConf* self, const gchar* key, GError **err)
 189 {
 190         ModestConfPrivate *priv;
 191
 192         g_return_val_if_fail (self, FALSE);
 193         g_return_val_if_fail (key, FALSE);
 194
 195         priv = MODEST_CONF_GET_PRIVATE(self);
 196
 197         return gconf_client_get_bool (priv->gconf_client, key, err);
 198 }
 199
 200
 201 gboolean
 202 modest_conf_set_string (ModestConf* self, const gchar* key, const gchar* val,
 203                         GError **err)
 204 {
 205         ModestConfPrivate *priv;
 206
 207         g_return_val_if_fail (self,FALSE);
 208         g_return_val_if_fail (key, FALSE);
 209
 210         priv = MODEST_CONF_GET_PRIVATE(self);
 211
 212         if (!gconf_client_key_is_writable(priv->gconf_client,key,err)) {
 213                 g_warning ("'%s' is not writable", key);
 214                 return FALSE;
 215         }
 216
 217         return gconf_client_set_string (priv->gconf_client, key, val, err);
 218 }
 219
 220
 221 gboolean
 222 modest_conf_set_int  (ModestConf* self, const gchar* key, gint val,
 223                       GError **err)
 224 {
 225         ModestConfPrivate *priv;
 226
 227         g_return_val_if_fail (self,FALSE);
 228         g_return_val_if_fail (key, FALSE);
 229
 230         priv = MODEST_CONF_GET_PRIVATE(self);
 231
 232         if (!gconf_client_key_is_writable(priv->gconf_client,key,err)) {
 233                 g_warning ("'%s' is not writable", key);
 234                 return FALSE;
 235         }
 236
 237         return gconf_client_set_int (priv->gconf_client, key, val, err);
 238 }
 239
 240
 241 gboolean
 242 modest_conf_set_bool (ModestConf* self, const gchar* key, gboolean val,
 243                       GError **err)
 244 {
 245         ModestConfPrivate *priv;
 246
 247         g_return_val_if_fail (self,FALSE);
 248         g_return_val_if_fail (key, FALSE);
 249
 250         priv = MODEST_CONF_GET_PRIVATE(self);
 251
 252         if (!gconf_client_key_is_writable(priv->gconf_client,key, err)) {
 253                 g_warning ("'%s' is not writable", key);
 254                 return FALSE;
 255         }
 256
 257         return gconf_client_set_bool (priv->gconf_client,key,val, err);
 258 }
 259
 260
 261
 262
 263 GSList*
 264 modest_conf_list_subkeys (ModestConf* self, const gchar* key, GError **err)
 265 {
 266         ModestConfPrivate *priv;
 267
 268         g_return_val_if_fail (self,FALSE);
 269         g_return_val_if_fail (key, FALSE);
 270
 271         priv = MODEST_CONF_GET_PRIVATE(self);
 272
 273         return gconf_client_all_dirs (priv->gconf_client,key,err);
 274 }
 275
 276
 277 gboolean
 278 modest_conf_remove_key (ModestConf* self, const gchar* key, GError **err)
 279 {
 280         ModestConfPrivate *priv;
 281
 282         g_return_val_if_fail (self,FALSE);
 283         g_return_val_if_fail (key, FALSE);
 284
 285         priv = MODEST_CONF_GET_PRIVATE(self);
 286
 287         return gconf_client_recursive_unset (priv->gconf_client,key,0,err);
 288 }
 289
 290
 291
 292
 293 gboolean
 294 modest_conf_key_exists (ModestConf* self, const gchar* key, GError **err)
 295 {
 296         ModestConfPrivate *priv;
 297
 298         g_return_val_if_fail (self,FALSE);
 299         g_return_val_if_fail (key, FALSE);
 300
 301         priv = MODEST_CONF_GET_PRIVATE(self);
 302
 303         return gconf_client_dir_exists (priv->gconf_client,key,err);
 304 }
 305
 306
 307
 308
 309
 310 static void
 311 modest_conf_on_change (GConfClient *client, guint conn_id, GConfEntry *entry,
 312                         gpointer data)
 313 {
 314         ModestConf *modest_conf = data;
 315
 316         if (!entry->value) {
 317                 g_print ("modest: key '%s' unset\n",
 318                          gconf_entry_get_key (entry));
 319                 g_signal_emit (modest_conf, signals[KEY_CHANGED_SIGNAL], 0,
 320                                gconf_entry_get_key (entry), NULL);
 321         } else {
 322                 gchar *val = gconf_value_to_string (gconf_entry_get_value(entry));
 323                 g_print ("modest: key '%s' set to '%s'\n",
 324                          gconf_entry_get_key (entry), val);
 325                 g_signal_emit (modest_conf, signals[KEY_CHANGED_SIGNAL], 0,
 326                                gconf_entry_get_key (entry), val);
 327                 g_free (val);
 328         }
 329 }