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

   1 /* modest-account-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <string.h>
   6 #include "modest-marshal.h"
   7 #include "modest-account-keys.h"
   8 #include "modest-account-mgr.h"
   9
  10 /* 'private'/'protected' functions */
  11 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
  12 static void modest_account_mgr_init (ModestAccountMgr * obj);
  13 static void modest_account_mgr_finalize (GObject * obj);
  14
  15 static gchar *get_account_keyname (const gchar * accname, const gchar * name);
  16 static gchar *get_server_account_keyname (const gchar * accname,
  17                                           const gchar * name);
  18
  19 /* list my signals */
  20 enum {
  21         ACCOUNT_CHANGE_SIGNAL,
  22         ACCOUNT_REMOVE_SIGNAL,
  23         ACCOUNT_ADD_SIGNAL,
  24         LAST_SIGNAL
  25 };
  26
  27 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
  28 struct _ModestAccountMgrPrivate {
  29         ModestConf *modest_conf;
  30         GSList *current_accounts;
  31 };
  32
  33 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  34                                                 MODEST_TYPE_ACCOUNT_MGR, \
  35                                                 ModestAccountMgrPrivate))
  36 /* globals */
  37 static GObjectClass *parent_class = NULL;
  38
  39 static guint signals[LAST_SIGNAL] = {0};
  40
  41
  42 static GSList *
  43 delete_account_from_list (GSList *list, const gchar *name)
  44 {
  45         GSList *iter, *result;
  46
  47         iter = list;
  48         result = list;
  49         while (iter) {
  50                 if (!strcmp (name, iter->data)) {
  51                         result = g_slist_delete_link (list, iter);
  52                         break;
  53                 }
  54
  55                 iter = g_slist_next (iter);
  56         }
  57         return result;
  58 }
  59
  60 static GSList *
  61 find_account_in_list (GSList *list, const gchar *name)
  62 {
  63         GSList *iter, *result;
  64
  65         iter = list;
  66         result = list;
  67         while (iter) {
  68                 if (!strcmp (name, iter->data)) {
  69                         return iter;
  70                         break;
  71                 }
  72
  73                 iter = g_slist_next (iter);
  74         }
  75         return NULL;
  76 }
  77
  78 /* Map configuration changes to account changes.
  79  * Doing this here makes sure all changes are available and external changes
  80  * are covered as well. */
  81
  82 static void
  83 modest_account_mgr_check_change (ModestConf *conf, const gchar *key,
  84                                  const gchar *new_value, gpointer user_data)
  85 {
  86         ModestAccountMgr *amgr = user_data;
  87         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (amgr);
  88
  89         if ((strlen (key) > strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/")
  90              && g_str_has_prefix (key, MODEST_SERVER_ACCOUNT_NAMESPACE))) {
  91                 gchar *subkey = key + strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
  92                 if (! strstr (subkey, "/")) {/* no more '/' means an account was modified */
  93                         if (new_value)  {
  94                                  /* covers only one case of two */
  95                                 priv->current_accounts =
  96                                         g_slist_prepend (priv->current_accounts, g_strdup (subkey));
  97                                 g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
  98                         } else {
  99                                 priv->current_accounts =
 100                                         delete_account_from_list (priv->current_accounts, subkey);
 101
 102                                 g_signal_emit (amgr, signals[ACCOUNT_REMOVE_SIGNAL], 0, subkey);
 103                         }
 104                 } else {
 105                         gchar *param;
 106
 107                         param = strstr (subkey, "/");
 108                         param [0] = 0;
 109                         param++;
 110
 111                         /* that's the second case for a new account */
 112                         if (!find_account_in_list (priv->current_accounts, subkey)) {
 113                                 priv->current_accounts =
 114                                         g_slist_prepend (priv->current_accounts, g_strdup (subkey));
 115                                 g_signal_emit (amgr, signals[ACCOUNT_ADD_SIGNAL], 0, subkey);
 116                         }
 117
 118                         g_signal_emit (amgr, signals[ACCOUNT_CHANGE_SIGNAL], 0, subkey, param, new_value);
 119                 }
 120         }
 121
 122         g_message ("value changed: %s %s\n", key, new_value);
 123 }
 124
 125
 126 GType
 127 modest_account_mgr_get_type (void)
 128 {
 129         static GType my_type = 0;
 130
 131         if (!my_type) {
 132                 static const GTypeInfo my_info = {
 133                         sizeof (ModestAccountMgrClass),
 134                         NULL,   /* base init */
 135                         NULL,   /* base finalize */
 136                         (GClassInitFunc) modest_account_mgr_class_init,
 137                         NULL,   /* class finalize */
 138                         NULL,   /* class data */
 139                         sizeof (ModestAccountMgr),
 140                         1,      /* n_preallocs */
 141                         (GInstanceInitFunc) modest_account_mgr_init,
 142                 };
 143
 144                 my_type = g_type_register_static (G_TYPE_OBJECT,
 145                                                   "ModestAccountMgr",
 146                                                   &my_info, 0);
 147         }
 148         return my_type;
 149 }
 150
 151 static void
 152 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
 153 {
 154         GObjectClass *gobject_class;
 155         GType paramtypes[3] = {G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER};
 156
 157         gobject_class = (GObjectClass *) klass;
 158
 159         parent_class = g_type_class_peek_parent (klass);
 160         gobject_class->finalize = modest_account_mgr_finalize;
 161
 162         g_type_class_add_private (gobject_class,
 163                                   sizeof (ModestAccountMgrPrivate));
 164
 165         /* signal definitions */
 166         signals[ACCOUNT_ADD_SIGNAL] =
 167                 g_signal_newv ("account-add",
 168                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 169                                NULL, NULL, NULL,
 170                                g_cclosure_marshal_VOID__POINTER,
 171                                G_TYPE_NONE, 1, paramtypes);
 172
 173         signals[ACCOUNT_REMOVE_SIGNAL] =
 174                 g_signal_newv ("account-remove",
 175                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 176                                NULL, NULL, NULL,
 177                                g_cclosure_marshal_VOID__POINTER,
 178                                G_TYPE_NONE, 1, paramtypes);
 179         signals[ACCOUNT_CHANGE_SIGNAL] =
 180                 g_signal_newv ("account-change",
 181                                G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 182                                NULL, NULL, NULL,
 183                                modest_marshal_VOID__POINTER_POINTER_POINTER,
 184                                G_TYPE_NONE, 3, paramtypes);
 185 }
 186
 187
 188 static void
 189 modest_account_mgr_init (ModestAccountMgr * obj)
 190 {
 191         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 192
 193         priv->modest_conf = NULL;
 194 }
 195
 196 static void
 197 modest_account_mgr_finalize (GObject * obj)
 198 {
 199         ModestAccountMgr *self = MODEST_ACCOUNT_MGR (obj);
 200         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 201
 202         if (priv->modest_conf) {
 203                 g_object_unref (G_OBJECT(priv->modest_conf));
 204                 priv->modest_conf = NULL;
 205         }
 206 }
 207
 208 GObject *
 209 modest_account_mgr_new (ModestConf * conf)
 210 {
 211         GObject *obj;
 212         ModestAccountMgrPrivate *priv;
 213
 214         g_return_val_if_fail (conf, NULL);
 215
 216         obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
 217         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
 218
 219         /*
 220          * increase the ref count on the modest_conf. Normally, the
 221          * ModestConf should outlive the ModestAccountMgr though
 222          */
 223         g_object_ref (G_OBJECT (priv->modest_conf = conf));
 224
 225         priv->current_accounts = modest_account_mgr_account_names (MODEST_ACCOUNT_MGR(obj), NULL);
 226
 227         g_signal_connect (G_OBJECT (conf), "key-changed",
 228                           G_CALLBACK (modest_account_mgr_check_change), obj);
 229         return obj;
 230 }
 231
 232
 233 gboolean
 234 modest_account_mgr_add_account (ModestAccountMgr * self, const gchar * name,
 235                                 const gchar * store_account,
 236                                 const gchar * transport_account,
 237                                 GError ** err)
 238 {
 239         ModestAccountMgrPrivate *priv;
 240         gchar *key;
 241
 242         g_return_val_if_fail (self, FALSE);
 243         g_return_val_if_fail (name, FALSE);
 244
 245         if (modest_account_mgr_account_exists (self, name, err)) {
 246                 g_warning ("account already exists");
 247                 //return FALSE;
 248         }
 249         /*
 250          * we create the account by adding an account 'dir', with the name <name>,
 251          * and in that the 'display_name' string key
 252          */
 253         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 254
 255         key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 256         modest_conf_set_string (priv->modest_conf, key, name, err);
 257         g_free (key);
 258
 259         if (store_account) {
 260                 key = get_account_keyname (name,
 261                                            MODEST_ACCOUNT_STORE_ACCOUNT);
 262                 modest_conf_set_string (priv->modest_conf, key, store_account,
 263                                         err);
 264                 g_free (key);
 265         }
 266
 267         if (transport_account) {
 268                 key = get_account_keyname (name,
 269                                            MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
 270                 modest_conf_set_string (priv->modest_conf, key,
 271                                         transport_account, err);
 272                 g_free (key);
 273         }
 274
 275         return TRUE;            /* TODO: error handling */
 276 }
 277
 278
 279 gboolean
 280 modest_account_mgr_remove_account (ModestAccountMgr * self,
 281                                    const gchar * name, GError ** err)
 282 {
 283         ModestAccountMgrPrivate *priv;
 284         gchar *key;
 285         gboolean retval;
 286
 287         g_return_val_if_fail (self, FALSE);
 288         g_return_val_if_fail (name, FALSE);
 289
 290         if (!modest_account_mgr_account_exists (self, name, err)) {
 291                 g_warning ("account doest not exist");
 292                 return FALSE;
 293         }
 294
 295         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 296         key = get_account_keyname (name, NULL);
 297
 298         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 299
 300         g_free (key);
 301         return retval;
 302 }
 303
 304
 305 static const gchar *
 306 null_means_empty (const gchar * str)
 307 {
 308         return str ? str : "";
 309 }
 310
 311
 312 gboolean
 313 modest_account_mgr_add_server_account (ModestAccountMgr * self,
 314                                        const gchar * name,
 315                                        const gchar * hostname,
 316                                        const gchar * username,
 317                                        const gchar * password,
 318                                        const gchar * proto)
 319 {
 320         ModestAccountMgrPrivate *priv;
 321         gchar *acckey, *key;
 322
 323         g_return_val_if_fail (self, FALSE);
 324         g_return_val_if_fail (name, FALSE);
 325
 326         /* TODO: check already exists */
 327
 328         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 329         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 330                               name, NULL);
 331
 332         if (modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 333                 g_warning ("server account %s already exists", name);
 334                 //g_free (acckey);
 335                 //return FALSE;
 336         }
 337
 338         /* hostname */
 339         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 340         modest_conf_set_string (priv->modest_conf, key,
 341                                 null_means_empty (hostname), NULL);
 342         g_free (key);
 343
 344         /* username */
 345         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 346         modest_conf_set_string (priv->modest_conf, key,
 347                                 null_means_empty (username), NULL);
 348         g_free (key);
 349
 350         /* password */
 351         if (password) {
 352                 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD,
 353                                    NULL);
 354                 modest_conf_set_string (priv->modest_conf, key,
 355                                         null_means_empty (password), NULL);
 356                 g_free (key);
 357         }
 358
 359         /* proto */
 360         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 361         modest_conf_set_string (priv->modest_conf, key,
 362                                 null_means_empty (proto), NULL);
 363         g_free (key);
 364         g_free (acckey);
 365
 366         return TRUE;            /* FIXME: better error checking */
 367 }
 368
 369 gboolean
 370 modest_account_mgr_remove_server_account (ModestAccountMgr * self,
 371                                           const gchar * name, GError ** err)
 372 {
 373         ModestAccountMgrPrivate *priv;
 374         gchar *acckey;
 375         gboolean retval;
 376
 377         g_return_val_if_fail (self, FALSE);
 378         g_return_val_if_fail (name, FALSE);
 379
 380         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 381
 382         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 383                               name, NULL);
 384
 385         if (!modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
 386                 g_warning ("server account %s does not exist exist", name);
 387                 g_free (acckey);
 388                 return FALSE;
 389         }
 390
 391         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 392         g_free (acckey);
 393
 394         return retval;
 395 }
 396
 397
 398 /* strip the first /n/ character from each element */
 399 /* caller must make sure all elements are strings with
 400  * length >= n, and also that data can be freed.
 401  */
 402 static GSList *
 403 strip_prefix_from_elements (GSList * lst, guint n)
 404 {
 405         GSList *cursor = lst;
 406
 407         while (cursor) {
 408                 gchar *str = (gchar *) cursor->data;
 409
 410                 cursor->data = g_strdup (str + n);
 411                 g_free (str);
 412                 cursor = cursor->next;
 413         }
 414         return lst;
 415 }
 416
 417
 418 GSList *
 419 modest_account_mgr_server_account_names (ModestAccountMgr * self,
 420                                          const gchar * account_name,
 421                                          ModestProtoType type,
 422                                          const gchar * proto,
 423                                          gboolean only_enabled)
 424 {
 425         GSList *accounts;
 426         GSList *cursor;
 427         ModestAccountMgrPrivate *priv;
 428         const size_t prefix_len =
 429                 strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
 430
 431         g_return_val_if_fail (self, NULL);
 432
 433         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 434         accounts = modest_conf_list_subkeys (priv->modest_conf,
 435                                              MODEST_SERVER_ACCOUNT_NAMESPACE,
 436                                              NULL);
 437
 438         /* no restrictions, return everything */
 439         if (type == MODEST_PROTO_TYPE_ANY && !proto)
 440                 return strip_prefix_from_elements (accounts, prefix_len);
 441
 442         /* otherwise, filter out the none-matching ones */
 443         cursor = accounts;
 444         while (cursor) {
 445                 gchar *keyspace, *proto_key, *acc_proto;
 446
 447                 keyspace = (gchar *) cursor->data;
 448                 proto_key =
 449                         g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO,
 450                                      NULL);
 451                 acc_proto =
 452                         modest_conf_get_string (priv->modest_conf, proto_key,
 453                                                 NULL);
 454                 g_free (proto_key);
 455
 456                 if ((!acc_proto) ||     /* proto not defined? */
 457                     (type != MODEST_PROTO_TYPE_ANY &&   /* proto type ...     */
 458                      modest_proto_type (acc_proto) != type) ||  /* ... matches?       */
 459                     (proto && strcmp (proto, acc_proto) != 0)) {        /* proto matches?     */
 460                         /* no match: remove from the list */
 461                         GSList *nxt = cursor->next;
 462
 463                         g_free (acc_proto);
 464                         accounts = g_slist_delete_link (accounts, cursor);
 465                         cursor = nxt;
 466                 } else
 467                         cursor = cursor->next;
 468         }
 469
 470         return strip_prefix_from_elements (accounts, prefix_len);
 471 }
 472
 473
 474 GSList *
 475 modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
 476 {
 477         GSList *accounts;
 478         ModestAccountMgrPrivate *priv;
 479         const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
 480
 481
 482         g_return_val_if_fail (self, NULL);
 483
 484         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 485
 486         accounts = modest_conf_list_subkeys (priv->modest_conf,
 487                                              MODEST_ACCOUNT_NAMESPACE, err);
 488         return strip_prefix_from_elements (accounts, prefix_len);
 489 }
 490
 491
 492 static gchar *
 493 get_account_string (ModestAccountMgr * self, const gchar * name,
 494                     const gchar * key, gboolean server_account, GError ** err)
 495 {
 496         ModestAccountMgrPrivate *priv;
 497
 498         gchar *keyname;
 499         gchar *retval;
 500
 501         g_return_val_if_fail (self, NULL);
 502         g_return_val_if_fail (name, NULL);
 503         g_return_val_if_fail (key, NULL);
 504
 505         if (server_account)
 506                 keyname = get_server_account_keyname (name, key);
 507         else
 508                 keyname = get_account_keyname (name, key);
 509
 510         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 511         retval = modest_conf_get_string (priv->modest_conf, keyname, err);
 512         g_free (keyname);
 513
 514         return retval;
 515 }
 516
 517
 518 gchar *
 519 modest_account_mgr_get_server_account_string (ModestAccountMgr * self,
 520                                               const gchar * name,
 521                                               const gchar * key,
 522                                               GError ** err)
 523 {
 524         return get_account_string (self, name, key, TRUE, err);
 525 }
 526
 527
 528 gchar *
 529 modest_account_mgr_get_account_string (ModestAccountMgr * self,
 530                                        const gchar * name, const gchar * key,
 531                                        GError ** err)
 532 {
 533         return get_account_string (self, name, key, FALSE, err);
 534 }
 535
 536
 537 static gint
 538 get_account_int (ModestAccountMgr * self, const gchar * name,
 539                  const gchar * key, gboolean server_account, GError ** err)
 540 {
 541         ModestAccountMgrPrivate *priv;
 542
 543         gchar *keyname;
 544         gint retval;
 545
 546         g_return_val_if_fail (self, -1);
 547         g_return_val_if_fail (name, -1);
 548         g_return_val_if_fail (key, -1);
 549
 550         if (server_account)
 551                 keyname = get_server_account_keyname (name, key);
 552         else
 553                 keyname = get_account_keyname (name, key);
 554
 555         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 556         retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 557         g_free (keyname);
 558
 559         return retval;
 560 }
 561
 562
 563 gint
 564 modest_account_mgr_get_server_account_int (ModestAccountMgr * self,
 565                                            const gchar * name,
 566                                            const gchar * key, GError ** err)
 567 {
 568         return get_account_int (self, name, key, TRUE, err);
 569 }
 570
 571
 572 gint
 573 modest_account_mgr_get_account_int (ModestAccountMgr * self,
 574                                     const gchar * name, const gchar * key,
 575                                     GError ** err)
 576 {
 577         return get_account_int (self, name, key, FALSE, err);
 578 }
 579
 580
 581 static gboolean
 582 get_account_bool (ModestAccountMgr * self, const gchar * name,
 583                   const gchar * key, gboolean server_account, GError ** err)
 584 {
 585         ModestAccountMgrPrivate *priv;
 586
 587         gchar *keyname;
 588         gboolean retval;
 589
 590         g_return_val_if_fail (self, FALSE);
 591         g_return_val_if_fail (name, FALSE);
 592         g_return_val_if_fail (key, FALSE);
 593
 594         if (server_account)
 595                 keyname = get_server_account_keyname (name, key);
 596         else
 597                 keyname = get_account_keyname (name, key);
 598
 599         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 600         retval = modest_conf_get_bool (priv->modest_conf, keyname, err);
 601         g_free (keyname);
 602
 603         return retval;
 604 }
 605
 606
 607 gint
 608 modest_account_mgr_get_server_account_bool (ModestAccountMgr * self,
 609                                             const gchar * name,
 610                                             const gchar * key, GError ** err)
 611 {
 612         return get_account_bool (self, name, key, TRUE, err);
 613 }
 614
 615
 616 gint
 617 modest_account_mgr_get_account_bool (ModestAccountMgr * self,
 618                                      const gchar * name, const gchar * key,
 619                                      GError ** err)
 620 {
 621         return get_account_bool (self, name, key, FALSE, err);
 622 }
 623
 624
 625 static gboolean
 626 set_account_string (ModestAccountMgr * self, const gchar * name,
 627                     const gchar * key, const gchar * val,
 628                     gboolean server_account, GError ** err)
 629 {
 630         ModestAccountMgrPrivate *priv;
 631
 632         gchar *keyname;
 633         gboolean retval;
 634
 635         g_return_val_if_fail (self, FALSE);
 636         g_return_val_if_fail (name, FALSE);
 637         g_return_val_if_fail (key, FALSE);
 638
 639         if (server_account)
 640                 keyname = get_server_account_keyname (name, key);
 641         else
 642                 keyname = get_account_keyname (name, key);
 643
 644         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 645
 646         retval = modest_conf_set_string (priv->modest_conf, keyname, val,
 647                                          err);
 648
 649         g_free (keyname);
 650         return retval;
 651 }
 652
 653
 654 gboolean
 655 modest_account_mgr_set_server_account_string (ModestAccountMgr * self,
 656                                               const gchar * name,
 657                                               const gchar * key,
 658                                               const gchar * val,
 659                                               GError ** err)
 660 {
 661         return set_account_string (self, name, key, val, TRUE, err);
 662 }
 663
 664
 665 gboolean
 666 modest_account_mgr_set_account_string (ModestAccountMgr * self,
 667                                        const gchar * name, const gchar * key,
 668                                        const gchar * val, GError ** err)
 669 {
 670         return set_account_string (self, name, key, val, FALSE, err);
 671 }
 672
 673
 674 static gboolean
 675 set_account_int (ModestAccountMgr * self, const gchar * name,
 676                  const gchar * key, gboolean server_account, int val,
 677                  GError ** err)
 678 {
 679         ModestAccountMgrPrivate *priv;
 680
 681         gchar *keyname;
 682         gboolean retval;
 683
 684         g_return_val_if_fail (self, FALSE);
 685         g_return_val_if_fail (name, FALSE);
 686         g_return_val_if_fail (key, FALSE);
 687
 688         if (server_account)
 689                 keyname = get_server_account_keyname (name, key);
 690         else
 691                 keyname = get_account_keyname (name, key);
 692
 693         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 694
 695         retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
 696
 697         g_free (keyname);
 698         return retval;
 699 }
 700
 701
 702 gboolean
 703 modest_account_mgr_set_server_account_int (ModestAccountMgr * self,
 704                                            const gchar * name,
 705                                            const gchar * key, int val,
 706                                            GError ** err)
 707 {
 708         return set_account_int (self, name, key, val, TRUE, err);
 709 }
 710
 711
 712 gboolean
 713 modest_account_mgr_set_account_int (ModestAccountMgr * self,
 714                                     const gchar * name, const gchar * key,
 715                                     int val, GError ** err)
 716 {
 717         return set_account_int (self, name, key, val, FALSE, err);
 718 }
 719
 720
 721 static gboolean
 722 set_account_bool (ModestAccountMgr * self, const gchar * name,
 723                   const gchar * key, gboolean server_account, gboolean val,
 724                   GError ** err)
 725 {
 726         ModestAccountMgrPrivate *priv;
 727
 728         gchar *keyname;
 729         gboolean retval;
 730
 731         g_return_val_if_fail (self, FALSE);
 732         g_return_val_if_fail (name, FALSE);
 733         g_return_val_if_fail (key, FALSE);
 734
 735         if (server_account)
 736                 keyname = get_server_account_keyname (name, key);
 737         else
 738                 keyname = get_account_keyname (name, key);
 739
 740         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 741
 742         retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
 743
 744         g_free (keyname);
 745         return retval;
 746 }
 747
 748
 749 gboolean
 750 modest_account_mgr_set_server_account_bool (ModestAccountMgr * self,
 751                                             const gchar * name,
 752                                             const gchar * key, gboolean val,
 753                                             GError ** err)
 754 {
 755         return set_account_bool (self, name, key, val, TRUE, err);
 756 }
 757
 758
 759 gboolean
 760 modest_account_mgr_set_account_bool (ModestAccountMgr * self,
 761                                      const gchar * name, const gchar * key,
 762                                      gboolean val, GError ** err)
 763 {
 764         return set_account_bool (self, name, key, val, FALSE, err);
 765 }
 766
 767
 768 gboolean
 769 account_exists (ModestAccountMgr * self, const gchar * name,
 770                 gboolean server_account, GError ** err)
 771 {
 772         ModestAccountMgrPrivate *priv;
 773
 774         gchar *keyname;
 775         gboolean retval;
 776
 777         g_return_val_if_fail (self, FALSE);
 778         g_return_val_if_fail (name, FALSE);
 779
 780         if (server_account)
 781                 keyname = get_server_account_keyname (name, NULL);
 782         else
 783                 keyname = get_account_keyname (name, NULL);
 784
 785         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 786         retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
 787
 788         g_free (keyname);
 789         return retval;
 790 }
 791
 792
 793 gboolean
 794 modest_account_mgr_server_account_exists (ModestAccountMgr * self,
 795                                           const gchar * name, GError ** err)
 796 {
 797         return account_exists (self, name, TRUE, err);
 798 }
 799
 800
 801 gboolean
 802 modest_account_mgr_account_exists (ModestAccountMgr * self,
 803                                    const gchar * name, GError ** err)
 804 {
 805         return account_exists (self, name, FALSE, err);
 806 }
 807
 808
 809 /* must be freed by caller */
 810 static gchar *
 811 get_account_keyname (const gchar * accname, const gchar * name)
 812 {
 813         if (name)
 814                 return g_strconcat
 815                         (MODEST_ACCOUNT_NAMESPACE, "/",
 816                          accname, "/", name, NULL);
 817         else
 818                 return g_strconcat
 819                         (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
 820 }
 821
 822
 823 /* must be freed by caller */
 824 static gchar *
 825 get_server_account_keyname (const gchar * accname, const gchar * name)
 826 {
 827         if (name)
 828                 return g_strconcat
 829                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 830                          accname, "/", name, NULL);
 831         else
 832                 return g_strconcat
 833                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, NULL);
 834 }