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

   1 /* Copyright (c) 2007, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <modest-account-settings.h>
  31
  32 /* 'private'/'protected' functions */
  33 static void   modest_account_settings_class_init (ModestAccountSettingsClass *klass);
  34 static void   modest_account_settings_finalize   (GObject *obj);
  35 static void   modest_account_settings_instance_init (ModestAccountSettings *obj);
  36
  37 typedef struct _ModestAccountSettingsPrivate ModestAccountSettingsPrivate;
  38 struct _ModestAccountSettingsPrivate {
  39         gchar *fullname;
  40         gchar *email_address;
  41         ModestAccountRetrieveType retrieve_type;
  42         gint retrieve_limit;
  43         gchar *display_name;
  44         gchar *account_name;
  45         ModestServerAccountSettings *store_settings;
  46         ModestServerAccountSettings *transport_settings;
  47         gboolean enabled;
  48         gboolean is_default;
  49         gboolean leave_messages_on_server;
  50         gboolean use_signature;
  51         gchar *signature;
  52         gboolean use_connection_specific_smtp;
  53 };
  54
  55 #define MODEST_ACCOUNT_SETTINGS_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  56                                                     MODEST_TYPE_ACCOUNT_SETTINGS, \
  57                                                     ModestAccountSettingsPrivate))
  58
  59 /* globals */
  60 static GObjectClass *parent_class = NULL;
  61
  62 GType
  63 modest_account_settings_get_type (void)
  64 {
  65         static GType my_type = 0;
  66
  67         if (!my_type) {
  68                 static const GTypeInfo my_info = {
  69                         sizeof(ModestAccountSettingsClass),
  70                         NULL,   /* base init */
  71                         NULL,   /* base finalize */
  72                         (GClassInitFunc) modest_account_settings_class_init,
  73                         NULL,   /* class finalize */
  74                         NULL,   /* class data */
  75                         sizeof(ModestAccountSettings),
  76                         0,      /* n_preallocs */
  77                         (GInstanceInitFunc) modest_account_settings_instance_init,
  78                         NULL
  79                 };
  80
  81                 my_type = g_type_register_static (G_TYPE_OBJECT,
  82                                                   "ModestAccountSettings",
  83                                                   &my_info, 0);
  84         }
  85         return my_type;
  86 }
  87
  88 static void
  89 modest_account_settings_class_init (ModestAccountSettingsClass *klass)
  90 {
  91         GObjectClass *gobject_class;
  92         gobject_class = (GObjectClass *) klass;
  93
  94         parent_class = g_type_class_peek_parent (klass);
  95         gobject_class->finalize = modest_account_settings_finalize;
  96
  97         g_type_class_add_private (gobject_class,
  98                                   sizeof(ModestAccountSettingsPrivate));
  99 }
 100
 101 static void
 102 modest_account_settings_instance_init (ModestAccountSettings *obj)
 103 {
 104         ModestAccountSettingsPrivate *priv;
 105
 106         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (obj);
 107
 108         priv->fullname = NULL;
 109         priv->email_address = NULL;
 110         priv->retrieve_type = MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY;
 111         priv->retrieve_limit = 0;
 112         priv->display_name = NULL;
 113         priv->account_name = NULL;
 114         priv->store_settings = NULL;
 115         priv->transport_settings = NULL;
 116         priv->enabled = TRUE;
 117         priv->is_default = FALSE;
 118         priv->leave_messages_on_server = TRUE;
 119         priv->use_signature = FALSE;
 120         priv->signature = FALSE;
 121         priv->use_connection_specific_smtp = FALSE;
 122 }
 123
 124 static void
 125 modest_account_settings_finalize   (GObject *obj)
 126 {
 127         ModestAccountSettings *settings = MODEST_ACCOUNT_SETTINGS (obj);
 128         ModestAccountSettingsPrivate *priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 129         g_free (priv->fullname);
 130         priv->fullname = NULL;
 131         g_free (priv->email_address);
 132         priv->email_address = NULL;
 133         g_free (priv->display_name);
 134         priv->display_name = NULL;
 135         g_free (priv->account_name);
 136         priv->account_name = NULL;
 137         g_free (priv->signature);
 138         priv->signature = FALSE;
 139         if (priv->store_settings) {
 140                 g_object_unref (priv->store_settings);
 141                 priv->store_settings = NULL;
 142         }
 143         if (priv->transport_settings) {
 144                 g_object_unref (priv->transport_settings);
 145                 priv->transport_settings = NULL;
 146         }
 147
 148         G_OBJECT_CLASS (parent_class)->finalize (obj);
 149 }
 150
 151 ModestAccountSettings*
 152 modest_account_settings_new (void)
 153 {
 154         return g_object_new (MODEST_TYPE_ACCOUNT_SETTINGS, NULL);
 155 }
 156
 157 const gchar*
 158 modest_account_settings_get_fullname (ModestAccountSettings *settings)
 159 {
 160         ModestAccountSettingsPrivate *priv;
 161
 162         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), NULL);
 163
 164         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 165         return priv->fullname;
 166 }
 167
 168 void
 169 modest_account_settings_set_fullname (ModestAccountSettings *settings,
 170                                              const gchar *fullname)
 171 {
 172         ModestAccountSettingsPrivate *priv;
 173
 174         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 175
 176         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 177         g_free (priv->fullname);
 178         priv->fullname = g_strdup (fullname);
 179 }
 180
 181 const gchar*
 182 modest_account_settings_get_email_address (ModestAccountSettings *settings)
 183 {
 184         ModestAccountSettingsPrivate *priv;
 185
 186         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), NULL);
 187
 188         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 189         return priv->email_address;
 190 }
 191
 192 void
 193 modest_account_settings_set_email_address (ModestAccountSettings *settings,
 194                                              const gchar *email_address)
 195 {
 196         ModestAccountSettingsPrivate *priv;
 197
 198         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 199
 200         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 201         g_free (priv->email_address);
 202         priv->email_address = g_strdup (email_address);
 203 }
 204
 205 const gchar*
 206 modest_account_settings_get_display_name (ModestAccountSettings *settings)
 207 {
 208         ModestAccountSettingsPrivate *priv;
 209
 210         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), NULL);
 211
 212         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 213         return priv->display_name;
 214 }
 215
 216 void
 217 modest_account_settings_set_display_name (ModestAccountSettings *settings,
 218                                              const gchar *display_name)
 219 {
 220         ModestAccountSettingsPrivate *priv;
 221
 222         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 223
 224         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 225         g_free (priv->display_name);
 226         priv->display_name = g_strdup (display_name);
 227 }
 228
 229 const gchar*
 230 modest_account_settings_get_account_name (ModestAccountSettings *settings)
 231 {
 232         ModestAccountSettingsPrivate *priv;
 233
 234         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), NULL);
 235
 236         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 237         return priv->account_name;
 238 }
 239
 240 void
 241 modest_account_settings_set_account_name (ModestAccountSettings *settings,
 242                                                  const gchar *account_name)
 243 {
 244         ModestAccountSettingsPrivate *priv;
 245
 246         /* be careful. This method should only be used internally in #ModestAccountMgr and
 247          * #ModestAccountSettings. */
 248
 249         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 250
 251         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 252         g_free (priv->account_name);
 253         priv->account_name = g_strdup (account_name);
 254 }
 255
 256 ModestAccountRetrieveType
 257 modest_account_settings_get_retrieve_type (ModestAccountSettings *settings)
 258 {
 259         ModestAccountSettingsPrivate *priv;
 260
 261         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY);
 262
 263         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 264         return priv->retrieve_type;
 265 }
 266
 267 void
 268 modest_account_settings_set_retrieve_type (ModestAccountSettings *settings,
 269                                            ModestAccountRetrieveType retrieve_type)
 270 {
 271         ModestAccountSettingsPrivate *priv;
 272
 273         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 274
 275         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 276         priv->retrieve_type = retrieve_type;
 277 }
 278
 279 gint
 280 modest_account_settings_get_retrieve_limit (ModestAccountSettings *settings)
 281 {
 282         ModestAccountSettingsPrivate *priv;
 283
 284         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 285
 286         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 287         return priv->retrieve_limit;
 288 }
 289
 290 void
 291 modest_account_settings_set_retrieve_limit (ModestAccountSettings *settings,
 292                                             gint retrieve_limit)
 293 {
 294         ModestAccountSettingsPrivate *priv;
 295
 296         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 297
 298         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 299         priv->retrieve_limit = retrieve_limit;
 300 }
 301
 302 gboolean
 303 modest_account_settings_get_enabled (ModestAccountSettings *settings)
 304 {
 305         ModestAccountSettingsPrivate *priv;
 306
 307         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 308
 309         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 310         return priv->enabled;
 311 }
 312
 313 void
 314 modest_account_settings_set_enabled (ModestAccountSettings *settings,
 315                                      gboolean enabled)
 316 {
 317         ModestAccountSettingsPrivate *priv;
 318
 319         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 320
 321         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 322         priv->enabled = enabled;
 323 }
 324
 325 gboolean
 326 modest_account_settings_get_is_default (ModestAccountSettings *settings)
 327 {
 328         ModestAccountSettingsPrivate *priv;
 329
 330         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 331
 332         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 333         return priv->is_default;
 334 }
 335
 336 void
 337 modest_account_settings_set_is_default (ModestAccountSettings *settings,
 338                                      gboolean is_default)
 339 {
 340         ModestAccountSettingsPrivate *priv;
 341
 342         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 343
 344         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 345         priv->is_default = is_default;
 346 }
 347
 348 ModestServerAccountSettings *
 349 modest_account_settings_get_store_settings (ModestAccountSettings *settings)
 350 {
 351         ModestAccountSettingsPrivate *priv;
 352
 353         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 354
 355         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 356         if (!priv->store_settings)
 357                 priv->store_settings = modest_server_account_settings_new ();
 358         return g_object_ref (priv->store_settings);
 359 }
 360
 361 void
 362 modest_account_settings_set_store_settings (ModestAccountSettings *settings,
 363                                             ModestServerAccountSettings *store_settings)
 364 {
 365         ModestAccountSettingsPrivate *priv;
 366
 367         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 368
 369         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 370
 371         if (priv->store_settings) {
 372                 g_object_unref (priv->store_settings);
 373                 priv->store_settings = NULL;
 374         }
 375
 376         if (MODEST_IS_SERVER_ACCOUNT_SETTINGS (store_settings))
 377                 priv->store_settings = g_object_ref (store_settings);
 378 }
 379
 380 ModestServerAccountSettings *
 381 modest_account_settings_get_transport_settings (ModestAccountSettings *settings)
 382 {
 383         ModestAccountSettingsPrivate *priv;
 384
 385         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 386
 387         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 388         if (!priv->transport_settings)
 389                 priv->transport_settings = modest_server_account_settings_new ();
 390         return g_object_ref (priv->transport_settings);
 391 }
 392
 393 void
 394 modest_account_settings_set_transport_settings (ModestAccountSettings *settings,
 395                                             ModestServerAccountSettings *transport_settings)
 396 {
 397         ModestAccountSettingsPrivate *priv;
 398
 399         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 400
 401         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 402
 403         if (priv->transport_settings) {
 404                 g_object_unref (priv->transport_settings);
 405                 priv->transport_settings = NULL;
 406         }
 407
 408         if (MODEST_IS_SERVER_ACCOUNT_SETTINGS (transport_settings))
 409                 priv->transport_settings = g_object_ref (transport_settings);
 410 }
 411
 412 gboolean
 413 modest_account_settings_get_use_signature (ModestAccountSettings *settings)
 414 {
 415         ModestAccountSettingsPrivate *priv;
 416
 417         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 418
 419         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 420         return priv->use_signature;
 421 }
 422
 423 void
 424 modest_account_settings_set_use_signature (ModestAccountSettings *settings,
 425                                      gboolean use_signature)
 426 {
 427         ModestAccountSettingsPrivate *priv;
 428
 429         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 430
 431         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 432         priv->use_signature = use_signature;
 433 }
 434
 435 const gchar*
 436 modest_account_settings_get_signature (ModestAccountSettings *settings)
 437 {
 438         ModestAccountSettingsPrivate *priv;
 439
 440         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), NULL);
 441
 442         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 443         return priv->signature;
 444 }
 445
 446 void
 447 modest_account_settings_set_signature (ModestAccountSettings *settings,
 448                                              const gchar *signature)
 449 {
 450         ModestAccountSettingsPrivate *priv;
 451
 452         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 453
 454         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 455         g_free (priv->signature);
 456         priv->signature = g_strdup (signature);
 457 }
 458
 459 gboolean
 460 modest_account_settings_get_leave_messages_on_server (ModestAccountSettings *settings)
 461 {
 462         ModestAccountSettingsPrivate *priv;
 463
 464         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 465
 466         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 467         return priv->leave_messages_on_server;
 468 }
 469
 470 void
 471 modest_account_settings_set_leave_messages_on_server (ModestAccountSettings *settings,
 472                                      gboolean leave_messages_on_server)
 473 {
 474         ModestAccountSettingsPrivate *priv;
 475
 476         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 477
 478         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 479         priv->leave_messages_on_server = leave_messages_on_server;
 480 }
 481
 482 gboolean
 483 modest_account_settings_get_use_connection_specific_smtp (ModestAccountSettings *settings)
 484 {
 485         ModestAccountSettingsPrivate *priv;
 486
 487         g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), 0);
 488
 489         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 490         return priv->use_connection_specific_smtp;
 491 }
 492
 493 void
 494 modest_account_settings_set_use_connection_specific_smtp (ModestAccountSettings *settings,
 495                                                           gboolean use_connection_specific_smtp)
 496 {
 497         ModestAccountSettingsPrivate *priv;
 498
 499         g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
 500
 501         priv = MODEST_ACCOUNT_SETTINGS_GET_PRIVATE (settings);
 502         priv->use_connection_specific_smtp = use_connection_specific_smtp;
 503 }
 504