vcs.maemo.org Git - modest/blob - experimental/modest/src/modest-account-mgr.c

   1 /* modest-account-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <string.h>
   6 #include "modest-account-mgr.h"
   7
   8 /* 'private'/'protected' functions */
   9 static void    modest_account_mgr_class_init    (ModestAccountMgrClass *klass);
  10 static void    modest_account_mgr_init          (ModestAccountMgr *obj);
  11 static void    modest_account_mgr_finalize      (GObject *obj);
  12
  13 static gchar*  get_account_keyname (const gchar *accname, const gchar *name);
  14
  15
  16 /* list my signals */
  17 enum {
  18         /* MY_SIGNAL_1, */
  19         /* MY_SIGNAL_2, */
  20         LAST_SIGNAL
  21 };
  22
  23 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
  24 struct _ModestAccountMgrPrivate {
  25         ModestConf *modest_conf;
  26 };
  27 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  28                                                 MODEST_TYPE_ACCOUNT_MGR, \
  29                                                 ModestAccountMgrPrivate))
  30 /* globals */
  31 static GObjectClass *parent_class = NULL;
  32
  33 /* uncomment the following if you have defined any signals */
  34 /* static guint signals[LAST_SIGNAL] = {0}; */
  35
  36 GType
  37 modest_account_mgr_get_type (void)
  38 {
  39         static GType my_type = 0;
  40         if (!my_type) {
  41                 static const GTypeInfo my_info = {
  42                         sizeof(ModestAccountMgrClass),
  43                         NULL,           /* base init */
  44                         NULL,           /* base finalize */
  45                         (GClassInitFunc) modest_account_mgr_class_init,
  46                         NULL,           /* class finalize */
  47                         NULL,           /* class data */
  48                         sizeof(ModestAccountMgr),
  49                         1,              /* n_preallocs */
  50                         (GInstanceInitFunc) modest_account_mgr_init,
  51                 };
  52
  53                 my_type = g_type_register_static (G_TYPE_OBJECT,
  54                                                   "ModestAccountMgr",
  55                                                   &my_info, 0);
  56         }
  57         return my_type;
  58 }
  59
  60 static void
  61 modest_account_mgr_class_init (ModestAccountMgrClass *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_account_mgr_finalize;
  68
  69         g_type_class_add_private (gobject_class, sizeof(ModestAccountMgrPrivate));
  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
  80 static void
  81 modest_account_mgr_init (ModestAccountMgr *obj)
  82 {
  83         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
  84         priv->modest_conf = NULL;
  85 }
  86
  87 static void
  88 modest_account_mgr_finalize (GObject *obj)
  89 {
  90         ModestAccountMgr *self = MODEST_ACCOUNT_MGR(obj);
  91         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
  92
  93         g_object_unref (G_OBJECT(priv->modest_conf));
  94         priv->modest_conf = NULL;
  95 }
  96
  97 GObject*
  98 modest_account_mgr_new (ModestConf *conf)
  99 {
 100         GObject *obj;
 101         ModestAccountMgrPrivate *priv;
 102
 103         g_return_val_if_fail (conf, NULL);
 104
 105         obj  = G_OBJECT(g_object_new(MODEST_TYPE_ACCOUNT_MGR, NULL));
 106         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
 107
 108         /*
 109          * increase the ref count on the modest_conf. Normally, the
 110          * ModestConf should outlive the ModestAccountMgr though
 111          */
 112         g_object_ref(G_OBJECT(priv->modest_conf = conf));
 113         return obj;
 114 }
 115
 116
 117
 118 gboolean
 119 modest_account_mgr_add_account (ModestAccountMgr *self, const gchar* name,
 120                         GError **err)
 121 {
 122         ModestAccountMgrPrivate *priv;
 123         gchar *key;
 124         gboolean retval;
 125
 126         g_return_val_if_fail (self, FALSE);
 127         g_return_val_if_fail (name, FALSE);
 128
 129         if (modest_account_mgr_account_exists (self, name, err)) {
 130                 g_warning ("account already exists");
 131                 return FALSE;
 132         }
 133         /*
 134          * we create the account by adding an account 'dir', with the name <name>,
 135          * and in that the 'display_name' string key
 136          */
 137         key = get_account_keyname (name, "display_name");
 138
 139         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 140         retval = modest_conf_set_string (priv->modest_conf, key, name, err);
 141
 142         g_free (key);
 143         return retval;
 144 }
 145
 146
 147 gboolean
 148 modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 149                            GError **err)
 150 {
 151         ModestAccountMgrPrivate *priv;
 152         gchar *key;
 153         gboolean retval;
 154
 155         g_return_val_if_fail (self, FALSE);
 156         g_return_val_if_fail (name, FALSE);
 157
 158         if (!modest_account_mgr_account_exists (self, name, err)) {
 159                 g_warning ("account doest not exist");
 160                 return FALSE;
 161         }
 162
 163         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 164         key = get_account_keyname (name, NULL);
 165
 166         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 167
 168         g_free (key);
 169         return retval;
 170 }
 171
 172
 173
 174 GSList*
 175 modest_account_mgr_account_names  (ModestAccountMgr *self, GError **err)
 176 {
 177         GSList *accounts, *cursor;
 178         ModestAccountMgrPrivate *priv;
 179
 180         g_return_val_if_fail (self, NULL);
 181
 182         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 183
 184         cursor = accounts = modest_conf_list_subkeys (priv->modest_conf,
 185                                                       MODEST_ACCOUNT_NAMESPACE,
 186                                                       err);
 187         while (cursor) {
 188                 gchar *account = cursor->data;
 189                 cursor->data = g_strdup (account +
 190                                          strlen(MODEST_ACCOUNT_NAMESPACE "/"));
 191                 g_free (account);
 192                 cursor = cursor->next;
 193         }
 194         return accounts;
 195 }
 196
 197
 198
 199
 200 gchar*
 201 modest_account_mgr_get_account_string (ModestAccountMgr *self, const gchar *name,
 202                                        const gchar *key, GError **err)
 203 {
 204         ModestAccountMgrPrivate *priv;
 205
 206         gchar *keyname;
 207         gchar *retval;
 208
 209         g_return_val_if_fail (self, NULL);
 210         g_return_val_if_fail (name, NULL);
 211         g_return_val_if_fail (key, NULL);
 212
 213         keyname = get_account_keyname (name, key);
 214         g_warning ("get key: %s", keyname);
 215
 216         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 217
 218         retval = modest_conf_get_string (priv->modest_conf,
 219                                          keyname, err);
 220
 221         g_free (keyname);
 222         return retval;
 223 }
 224
 225
 226
 227 gint
 228 modest_account_mgr_get_account_int (ModestAccountMgr *self, const gchar *name,
 229                                     const gchar *key, GError **err)
 230 {
 231         ModestAccountMgrPrivate *priv;
 232
 233         gchar *keyname;
 234         gint retval;
 235
 236         g_return_val_if_fail (self, -1);
 237         g_return_val_if_fail (name, -1);
 238         g_return_val_if_fail (key, -1);
 239
 240         keyname = get_account_keyname (name, key);
 241         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 242         retval = modest_conf_get_int (priv->modest_conf,keyname,err);
 243
 244         g_free (keyname);
 245         return retval;
 246 }
 247
 248
 249 gboolean modest_account_mgr_get_account_bool (ModestAccountMgr *self, const gchar *name,
 250                                               const gchar *key, GError **err)
 251 {
 252         ModestAccountMgrPrivate *priv;
 253
 254         gchar *keyname;
 255         gboolean retval;
 256
 257         g_return_val_if_fail (self, FALSE);
 258         g_return_val_if_fail (name, FALSE);
 259         g_return_val_if_fail (key, FALSE);
 260
 261         keyname = get_account_keyname (name, key);
 262         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 263         retval = modest_conf_get_bool (priv->modest_conf,keyname,err);
 264
 265         g_free (keyname);
 266         return retval;
 267 }
 268
 269
 270
 271 gboolean
 272 modest_account_mgr_set_account_string  (ModestAccountMgr *self, const gchar *name,
 273                                         const gchar *key, const gchar* val,
 274                                         GError **err)
 275 {
 276         ModestAccountMgrPrivate *priv;
 277
 278         gchar *keyname;
 279         gboolean retval;
 280
 281         g_return_val_if_fail (self, FALSE);
 282         g_return_val_if_fail (name, FALSE);
 283         g_return_val_if_fail (key, FALSE);
 284
 285         keyname = get_account_keyname (name, key);
 286         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 287         retval = modest_conf_set_string (priv->modest_conf,keyname,val,err);
 288
 289         g_free (keyname);
 290         return retval;
 291 }
 292
 293
 294
 295 gboolean
 296 modest_account_mgr_set_account_int  (ModestAccountMgr *self, const gchar *name,
 297                                      const gchar *key, gint val, GError **err)
 298 {
 299         ModestAccountMgrPrivate *priv;
 300
 301         gchar *keyname;
 302         gboolean retval;
 303
 304         g_return_val_if_fail (self, -1);
 305         g_return_val_if_fail (name, -1);
 306         g_return_val_if_fail (key, -1);
 307
 308         keyname = get_account_keyname (name, key);
 309         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 310         retval = modest_conf_set_int (priv->modest_conf,keyname,val,err);
 311
 312         g_free (keyname);
 313         return retval;
 314 }
 315
 316
 317
 318
 319 gboolean
 320 modest_account_mgr_set_account_bool  (ModestAccountMgr *self, const gchar *name,
 321                                       const gchar *key, gboolean val, GError **err)
 322 {
 323         ModestAccountMgrPrivate *priv;
 324
 325         gchar *keyname;
 326         gboolean retval;
 327
 328         g_return_val_if_fail (self, FALSE);
 329         g_return_val_if_fail (name, FALSE);
 330         g_return_val_if_fail (key, FALSE);
 331
 332         keyname = get_account_keyname (name, key);
 333         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 334         retval = modest_conf_set_bool (priv->modest_conf,keyname,val,err);
 335
 336         g_free (keyname);
 337         return retval;
 338 }
 339
 340
 341 gboolean
 342 modest_account_mgr_account_exists (ModestAccountMgr *self, const gchar *name,
 343                                    GError **err)
 344 {
 345         ModestAccountMgrPrivate *priv;
 346
 347         gchar *keyname;
 348         gboolean retval;
 349
 350         g_return_val_if_fail (self, FALSE);
 351         g_return_val_if_fail (name, FALSE);
 352
 353         keyname = get_account_keyname (name, NULL);
 354
 355         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 356         retval = modest_conf_key_exists (priv->modest_conf,keyname,err);
 357
 358         g_free (keyname);
 359         return retval;
 360 }
 361
 362
 363
 364 /* must be freed by caller */
 365 static gchar*
 366 get_account_keyname (const gchar *accname, const gchar *name)
 367 {
 368         if (name)
 369                 return g_strconcat
 370                         (MODEST_ACCOUNT_NAMESPACE, "/", accname, "/", name, NULL);
 371         else
 372                 return g_strconcat
 373                         (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
 374 }
 375