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