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

   1 /* Copyright (c) 2006, 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 <glib/gi18n.h>
  31 #include "modest-account-assistant.h"
  32 #include "modest-store-widget.h"
  33 #include "modest-transport-widget.h"
  34 #include "modest-text-utils.h"
  35 #include <modest-protocol-info.h>
  36
  37 #include <string.h>
  38
  39 /* 'private'/'protected' functions */
  40 static void       modest_account_assistant_class_init    (ModestAccountAssistantClass *klass);
  41 static void       modest_account_assistant_init          (ModestAccountAssistant *obj);
  42 static void       modest_account_assistant_finalize      (GObject *obj);
  43
  44 /* list my signals */
  45 enum {
  46         /* MY_SIGNAL_1, */
  47         /* MY_SIGNAL_2, */
  48         LAST_SIGNAL
  49 };
  50
  51 typedef struct _ModestAccountAssistantPrivate ModestAccountAssistantPrivate;
  52 struct _ModestAccountAssistantPrivate {
  53
  54         ModestWidgetFactory *factory;
  55         ModestAccountMgr *account_mgr;
  56
  57         GtkWidget *account_name;
  58         GtkWidget *fullname;
  59         GtkWidget *email;
  60
  61         GtkWidget *store_widget;
  62         GtkWidget *transport_widget;
  63
  64         GtkWidget *transport_holder;
  65         GtkWidget *store_holder;
  66 };
  67
  68 #define MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  69                                                       MODEST_TYPE_ACCOUNT_ASSISTANT, \
  70                                                       ModestAccountAssistantPrivate))
  71 /* globals */
  72 static GtkAssistantClass *parent_class = NULL;
  73
  74 /* uncomment the following if you have defined any signals */
  75 /* static guint signals[LAST_SIGNAL] = {0}; */
  76
  77 GType
  78 modest_account_assistant_get_type (void)
  79 {
  80         static GType my_type = 0;
  81         if (!my_type) {
  82                 static const GTypeInfo my_info = {
  83                         sizeof(ModestAccountAssistantClass),
  84                         NULL,           /* base init */
  85                         NULL,           /* base finalize */
  86                         (GClassInitFunc) modest_account_assistant_class_init,
  87                         NULL,           /* class finalize */
  88                         NULL,           /* class data */
  89                         sizeof(ModestAccountAssistant),
  90                         1,              /* n_preallocs */
  91                         (GInstanceInitFunc) modest_account_assistant_init,
  92                         NULL
  93                 };
  94                 my_type = g_type_register_static (GTK_TYPE_ASSISTANT,
  95                                                   "ModestAccountAssistant",
  96                                                   &my_info, 0);
  97         }
  98         return my_type;
  99 }
 100
 101 static void
 102 modest_account_assistant_class_init (ModestAccountAssistantClass *klass)
 103 {
 104         GObjectClass *gobject_class;
 105         gobject_class = (GObjectClass*) klass;
 106
 107         parent_class            = g_type_class_peek_parent (klass);
 108         gobject_class->finalize = modest_account_assistant_finalize;
 109
 110         g_type_class_add_private (gobject_class, sizeof(ModestAccountAssistantPrivate));
 111
 112         /* signal definitions go here, e.g.: */
 113 /*      signals[MY_SIGNAL_1] = */
 114 /*              g_signal_new ("my_signal_1",....); */
 115 /*      signals[MY_SIGNAL_2] = */
 116 /*              g_signal_new ("my_signal_2",....); */
 117 /*      etc. */
 118 }
 119
 120
 121
 122 static void
 123 add_intro_page (ModestAccountAssistant *assistant)
 124 {
 125         GtkWidget *page, *label;
 126
 127         page = gtk_vbox_new (FALSE, 6);
 128
 129         label = gtk_label_new (
 130                 _("Welcome to the account assistant\n\n"
 131                   "It will help to set up a new e-mail account\n"));
 132         gtk_box_pack_start (GTK_BOX(page), label, FALSE, FALSE, 6);
 133         gtk_widget_show_all (page);
 134
 135         gtk_assistant_append_page (GTK_ASSISTANT(assistant), page);
 136
 137         gtk_assistant_set_page_title (GTK_ASSISTANT(assistant), page,
 138                                       _("Modest Account Assistant"));
 139         gtk_assistant_set_page_type (GTK_ASSISTANT(assistant), page,
 140                                      GTK_ASSISTANT_PAGE_INTRO);
 141         gtk_assistant_set_page_complete (GTK_ASSISTANT(assistant),
 142                                          page, TRUE);
 143 }
 144
 145
 146 static void
 147 set_current_page_complete (ModestAccountAssistant *self, gboolean complete)
 148 {
 149         GtkWidget *page;
 150         gint pageno;
 151
 152         pageno = gtk_assistant_get_current_page (GTK_ASSISTANT(self));
 153
 154         if (pageno != -1) {
 155                 page   = gtk_assistant_get_nth_page (GTK_ASSISTANT(self), pageno);
 156                 gtk_assistant_set_page_complete (GTK_ASSISTANT(self), page, complete);
 157         }
 158 }
 159
 160
 161 static void
 162 identity_page_update_completeness (GtkEditable *editable,
 163                                    ModestAccountAssistant *self)
 164 {
 165         ModestAccountAssistantPrivate *priv;
 166         const gchar *txt;
 167
 168         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 169
 170         txt = gtk_entry_get_text (GTK_ENTRY(priv->fullname));
 171         if (!txt || strlen(txt) == 0) {
 172                 set_current_page_complete (self, FALSE);
 173                 return;
 174         }
 175
 176         /* FIXME: regexp check for email address */
 177         txt = gtk_entry_get_text (GTK_ENTRY(priv->email));
 178         if (!modest_text_utils_validate_email_address (txt))
 179                 set_current_page_complete (self, FALSE);
 180         else
 181                 set_current_page_complete (self, TRUE);
 182 }
 183
 184
 185 static void
 186 add_identity_page (ModestAccountAssistant *self)
 187 {
 188         GtkWidget *page, *label, *table;
 189         ModestAccountAssistantPrivate *priv;
 190
 191         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 192
 193         priv->fullname = gtk_entry_new_with_max_length (40);
 194         priv->email    = gtk_entry_new_with_max_length (40);
 195
 196         page = gtk_vbox_new (FALSE, 6);
 197
 198         label = gtk_label_new (
 199                 _("Please enter your name and your e-mail address below.\n\n"));
 200         gtk_box_pack_start (GTK_BOX(page), label, FALSE, FALSE, 6);
 201
 202         table = gtk_table_new (2,2, FALSE);
 203         gtk_table_attach_defaults (GTK_TABLE(table),gtk_label_new (_("Full name")),
 204                                    0,1,0,1);
 205         gtk_table_attach_defaults (GTK_TABLE(table),gtk_label_new (_("E-mail address")),
 206                                    0,1,1,2);
 207         gtk_table_attach_defaults (GTK_TABLE(table),priv->fullname,
 208                                    1,2,0,1);
 209         gtk_table_attach_defaults (GTK_TABLE(table),priv->email,
 210                                    1,2,1,2);
 211
 212         g_signal_connect (G_OBJECT(priv->fullname), "changed",
 213                           G_CALLBACK(identity_page_update_completeness),
 214                           self);
 215         g_signal_connect (G_OBJECT(priv->email), "changed",
 216                           G_CALLBACK(identity_page_update_completeness),
 217                           self);
 218
 219         gtk_box_pack_start (GTK_BOX(page), table, FALSE, FALSE, 6);
 220         gtk_widget_show_all (page);
 221
 222         gtk_assistant_append_page (GTK_ASSISTANT(self), page);
 223
 224         gtk_assistant_set_page_title (GTK_ASSISTANT(self), page,
 225                                       _("Identity"));
 226         gtk_assistant_set_page_type (GTK_ASSISTANT(self), page,
 227                                      GTK_ASSISTANT_PAGE_INTRO);
 228         gtk_assistant_set_page_complete (GTK_ASSISTANT(self),
 229                                          page, FALSE);
 230 }
 231
 232
 233 static void
 234 receiving_page_update_completeness (GtkEditable *editable,
 235                                     ModestAccountAssistant *self)
 236 {
 237         ModestAccountAssistantPrivate *priv;
 238         const gchar *txt;
 239
 240         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 241
 242         txt = modest_store_widget_get_username (MODEST_STORE_WIDGET (priv->store_widget));
 243         if (!txt || strlen(txt) == 0) {
 244                 set_current_page_complete (self, FALSE);
 245                 return;
 246         }
 247
 248         txt = modest_store_widget_get_servername (MODEST_STORE_WIDGET (priv->store_widget));
 249         if (!txt || strlen(txt) == 0) {
 250                 set_current_page_complete (self, FALSE);
 251                 return;
 252         }
 253         set_current_page_complete (self, TRUE);
 254 }
 255
 256 static void
 257 on_receiving_combo_box_changed (GtkComboBox *combo, ModestAccountAssistant *self)
 258 {
 259         ModestAccountAssistantPrivate *priv;
 260         gchar *chosen;
 261         ModestProtocol proto;
 262
 263         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 264         chosen = gtk_combo_box_get_active_text (GTK_COMBO_BOX(combo));
 265         if (priv->store_widget)
 266                 gtk_container_remove (GTK_CONTAINER(priv->store_holder),
 267                                       priv->store_widget);
 268
 269         proto = modest_protocol_info_get_protocol (chosen);
 270
 271         /* FIXME: we could have these widgets cached instead of
 272            creating them every time */
 273         priv->store_widget = modest_store_widget_new (priv->factory, proto);
 274         if (proto == MODEST_PROTOCOL_STORE_POP || proto == MODEST_PROTOCOL_STORE_IMAP) {
 275                 g_signal_connect (priv->store_widget,
 276                                   "data_changed",
 277                                   G_CALLBACK (receiving_page_update_completeness),
 278                                   self);
 279                 set_current_page_complete (self, FALSE);
 280         } else
 281                 set_current_page_complete (self, TRUE);
 282
 283         gtk_container_add (GTK_CONTAINER(priv->store_holder),
 284                            priv->store_widget);
 285
 286         gtk_widget_show_all (priv->store_holder);
 287
 288 }
 289
 290 static void
 291 add_receiving_page (ModestAccountAssistant *self)
 292 {
 293         GtkWidget *page, *box, *combo;
 294
 295         ModestAccountAssistantPrivate *priv;
 296
 297         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 298         page = gtk_vbox_new (FALSE, 6);
 299
 300         gtk_box_pack_start (GTK_BOX(page),
 301                             gtk_label_new (
 302                                     _("Please select among the following options")),
 303                             FALSE, FALSE, 6);
 304         box = gtk_hbox_new (FALSE, 6);
 305         gtk_box_pack_start (GTK_BOX(box),
 306                             gtk_label_new(_("Server type")),
 307                             FALSE,FALSE,6);
 308
 309         combo = modest_widget_factory_get_combo_box (priv->factory,
 310                                                      MODEST_COMBO_BOX_TYPE_STORE_PROTOS);
 311         g_signal_connect (G_OBJECT(combo), "changed",
 312                           G_CALLBACK(on_receiving_combo_box_changed), self);
 313
 314         gtk_box_pack_start (GTK_BOX(box), combo, FALSE,FALSE,6);
 315         gtk_box_pack_start (GTK_BOX(page), box, FALSE,FALSE, 6);
 316
 317         gtk_box_pack_start (GTK_BOX(page), gtk_hseparator_new(), FALSE, FALSE, 0);
 318
 319         priv->store_holder = gtk_hbox_new (FALSE, 0);
 320         gtk_box_pack_start (GTK_BOX(page), priv->store_holder,
 321                             TRUE, TRUE, 0);
 322
 323         /* Force the selection */
 324         on_receiving_combo_box_changed (GTK_COMBO_BOX (combo), self);
 325
 326         gtk_assistant_append_page (GTK_ASSISTANT(self), page);
 327
 328         gtk_assistant_set_page_title (GTK_ASSISTANT(self), page,
 329                                       _("Receiving mail"));
 330         gtk_assistant_set_page_type (GTK_ASSISTANT(self), page,
 331                                      GTK_ASSISTANT_PAGE_INTRO);
 332         gtk_assistant_set_page_complete (GTK_ASSISTANT(self),
 333                                          page, FALSE);
 334         gtk_widget_show_all (page);
 335 }
 336
 337
 338
 339
 340 static void
 341 on_sending_combo_box_changed (GtkComboBox *combo, ModestAccountAssistant *self)
 342 {
 343         ModestAccountAssistantPrivate *priv;
 344         gchar *chosen;
 345
 346         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 347
 348         chosen = gtk_combo_box_get_active_text (GTK_COMBO_BOX(combo));
 349
 350         if (priv->transport_widget)
 351                 gtk_container_remove (GTK_CONTAINER(priv->transport_holder),
 352                                       priv->transport_widget);
 353
 354         priv->transport_widget = modest_transport_widget_new (priv->factory,
 355                                                               modest_protocol_info_get_protocol(chosen));
 356
 357         gtk_container_add (GTK_CONTAINER(priv->transport_holder),
 358                            priv->transport_widget);
 359
 360         gtk_widget_show_all (priv->transport_holder);
 361 }
 362
 363
 364
 365 static void
 366 add_sending_page (ModestAccountAssistant *self)
 367 {
 368         GtkWidget *page, *box, *combo;
 369
 370         ModestAccountAssistantPrivate *priv;
 371
 372         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 373         page = gtk_vbox_new (FALSE, 6);
 374
 375         gtk_box_pack_start (GTK_BOX(page),
 376                             gtk_label_new (
 377                                     _("Please select among the following options")),
 378                             FALSE, FALSE, 0);
 379         box = gtk_hbox_new (FALSE, 0);
 380         gtk_box_pack_start (GTK_BOX(box),
 381                             gtk_label_new(_("Server type")),
 382                             FALSE,FALSE,0);
 383
 384         combo = modest_widget_factory_get_combo_box (priv->factory,
 385                                                      MODEST_COMBO_BOX_TYPE_TRANSPORT_PROTOS);
 386         g_signal_connect (G_OBJECT(combo), "changed",
 387                           G_CALLBACK(on_sending_combo_box_changed), self);
 388
 389         gtk_box_pack_start (GTK_BOX(box), combo, FALSE,FALSE,0);
 390         gtk_box_pack_start (GTK_BOX(page), box, FALSE,FALSE, 0);
 391
 392         gtk_box_pack_start (GTK_BOX(page), gtk_hseparator_new(), FALSE, FALSE, 0);
 393
 394         priv->transport_holder = gtk_hbox_new (FALSE, 0);
 395         gtk_box_pack_start (GTK_BOX(page), priv->transport_holder,
 396                             FALSE, FALSE, 0);
 397
 398         /* Force the selection */
 399         on_sending_combo_box_changed (GTK_COMBO_BOX (combo), self);
 400
 401         gtk_assistant_append_page (GTK_ASSISTANT(self), page);
 402
 403         gtk_assistant_set_page_title (GTK_ASSISTANT(self), page,
 404                                       _("Sending mail"));
 405         gtk_assistant_set_page_type (GTK_ASSISTANT(self), page,
 406                                      GTK_ASSISTANT_PAGE_INTRO);
 407         gtk_assistant_set_page_complete (GTK_ASSISTANT(self),
 408                                          page, TRUE);
 409         gtk_widget_show_all (page);
 410 }
 411
 412
 413
 414 static void
 415 add_final_page (ModestAccountAssistant *self)
 416 {
 417         GtkWidget *page, *box;
 418         ModestAccountAssistantPrivate *priv;
 419
 420         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 421         page = gtk_vbox_new (FALSE, 6);
 422
 423         gtk_box_pack_start (GTK_BOX(page),
 424                             gtk_label_new (
 425                                     _("We're almost done. Press 'Apply' to store this new account")),
 426                             FALSE, FALSE, 6);
 427         box = gtk_hbox_new (FALSE, 6);
 428         priv->account_name =
 429                 gtk_entry_new_with_max_length (40);
 430         gtk_entry_set_text (GTK_ENTRY(priv->account_name),
 431                             gtk_entry_get_text(GTK_ENTRY(priv->email)));
 432         gtk_box_pack_start (GTK_BOX(box),gtk_label_new(_("Account name:")),
 433                             FALSE,FALSE,6);
 434         gtk_box_pack_start (GTK_BOX(box),priv->account_name , FALSE,FALSE,6);
 435
 436         gtk_box_pack_start (GTK_BOX(page), box, FALSE, FALSE, 6);
 437
 438         gtk_assistant_append_page (GTK_ASSISTANT(self), page);
 439
 440         gtk_assistant_set_page_title (GTK_ASSISTANT(self), page,
 441                                       _("Account Management"));
 442         gtk_assistant_set_page_type (GTK_ASSISTANT(self), page,
 443                                      GTK_ASSISTANT_PAGE_CONFIRM);
 444
 445         gtk_assistant_set_page_complete (GTK_ASSISTANT(self),
 446                                          page, TRUE);
 447         gtk_widget_show_all (page);
 448 }
 449
 450
 451 static void
 452 modest_account_assistant_init (ModestAccountAssistant *obj)
 453 {
 454         ModestAccountAssistantPrivate *priv;
 455
 456         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(obj);
 457         priv->factory           = NULL;
 458         priv->account_mgr       = NULL;
 459
 460         priv->store_widget      = NULL;
 461         priv->transport_widget  = NULL;
 462 }
 463
 464 static void
 465 modest_account_assistant_finalize (GObject *obj)
 466 {
 467         ModestAccountAssistantPrivate *priv;
 468
 469         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(obj);
 470
 471         if (priv->factory) {
 472                 g_object_unref (G_OBJECT(priv->factory));
 473                 priv->factory = NULL;
 474         }
 475
 476         if (priv->account_mgr) {
 477                 g_object_unref (G_OBJECT(priv->account_mgr));
 478                 priv->account_mgr = NULL;
 479         }
 480
 481
 482
 483         G_OBJECT_CLASS(parent_class)->finalize (obj);
 484 }
 485
 486 static void
 487 on_cancel (ModestAccountAssistant *self, gpointer user_data)
 488 {
 489         GtkWidget *label;
 490         GtkWidget *dialog;
 491         int response;
 492
 493         label = gtk_label_new (_("Are you sure you want to cancel\n"
 494                                  "setting up a new account?"));
 495
 496         dialog = gtk_dialog_new_with_buttons (_("Cancel"),
 497                                               GTK_WINDOW(self),
 498                                               GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 499                                               GTK_STOCK_YES, GTK_RESPONSE_ACCEPT,
 500                                               GTK_STOCK_NO,  GTK_RESPONSE_CANCEL,
 501                                               NULL);
 502
 503         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
 504                             label, FALSE, FALSE, 6);
 505
 506         gtk_widget_show_all ((GTK_DIALOG(dialog)->vbox));
 507
 508         gtk_window_set_resizable (GTK_WINDOW(dialog), FALSE);
 509
 510         response = gtk_dialog_run (GTK_DIALOG(dialog));
 511         gtk_widget_destroy (dialog);
 512
 513         switch (response) {
 514         case GTK_RESPONSE_ACCEPT:
 515                 /* close the assistant */
 516                 gtk_widget_hide (GTK_WIDGET(self));
 517                 break;
 518         case GTK_RESPONSE_CANCEL:
 519                 /* don't do anything */
 520                 break;
 521         default: g_assert_not_reached ();
 522
 523         };
 524 }
 525
 526 static const gchar*
 527 get_account_name (ModestAccountAssistant *self)
 528 {
 529         ModestAccountAssistantPrivate *priv;
 530         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 531
 532         return gtk_entry_get_text (GTK_ENTRY(priv->account_name));
 533 }
 534
 535 static const gchar*
 536 get_fullname (ModestAccountAssistant *self)
 537 {
 538         ModestAccountAssistantPrivate *priv;
 539         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 540
 541         return gtk_entry_get_text (GTK_ENTRY(priv->fullname));
 542 }
 543
 544
 545
 546 static const gchar*
 547 get_email (ModestAccountAssistant *self)
 548 {
 549         ModestAccountAssistantPrivate *priv;
 550         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 551
 552         return gtk_entry_get_text (GTK_ENTRY(priv->email));
 553 }
 554
 555
 556 static void
 557 on_close (ModestAccountAssistant *self, gpointer user_data)
 558 {
 559         gtk_widget_hide (GTK_WIDGET (self));
 560 }
 561
 562
 563 /*
 564  * FIXME: hmmmm this a Camel internal thing, should move this
 565  * somewhere else
 566  */
 567 static gchar*
 568 get_account_uri (ModestProtocol proto, const gchar* path)
 569 {
 570         CamelURL *url;
 571         gchar *uri;
 572
 573         switch (proto) {
 574         case MODEST_PROTOCOL_STORE_MBOX:
 575                 url = camel_url_new ("mbox:", NULL); break;
 576         case MODEST_PROTOCOL_STORE_MAILDIR:
 577                 url = camel_url_new ("maildir:", NULL); break;
 578         default:
 579                 g_return_val_if_reached (NULL);
 580         }
 581         camel_url_set_path (url, path);
 582         uri = camel_url_to_string (url, 0);
 583         camel_url_free (url);
 584
 585         return uri;
 586 }
 587
 588 static gchar*
 589 get_new_server_account_name (ModestAccountMgr* acc_mgr, ModestProtocol proto,
 590                              const gchar* username, const gchar *servername)
 591 {
 592         gchar *name;
 593         gint  i = 0;
 594
 595         while (TRUE) {
 596                 name = g_strdup_printf ("%s:%d",
 597                                         modest_protocol_info_get_protocol_name(proto), i++);
 598                 if (modest_account_mgr_account_exists (acc_mgr, name, TRUE, NULL))
 599                         g_free (name);
 600                 else
 601                         break;
 602         }
 603         return name;
 604 }
 605
 606
 607 static void
 608 on_apply (ModestAccountAssistant *self, gpointer user_data)
 609 {
 610         ModestAccountAssistantPrivate *priv;
 611         ModestProtocol proto;
 612         gchar *store_name, *transport_name;
 613         const gchar *account_name, *username, *servername, *path;
 614         ModestStoreWidget *store;
 615         ModestTransportWidget *transport;
 616
 617         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 618
 619         /* create server account -> store */
 620         store = MODEST_STORE_WIDGET(priv->store_widget);
 621         proto    = modest_store_widget_get_proto (store);
 622         username = modest_store_widget_get_username (store);
 623         servername = modest_store_widget_get_servername (store);
 624         path       = modest_store_widget_get_path (store);
 625         store_name = get_new_server_account_name (priv->account_mgr, proto,username, servername);
 626
 627         if (proto == MODEST_PROTOCOL_STORE_MAILDIR ||
 628             proto == MODEST_PROTOCOL_STORE_MBOX) {
 629                 gchar *uri = get_account_uri (proto, path);
 630                 modest_account_mgr_add_server_account_uri (priv->account_mgr, store_name, proto, uri);
 631                 g_free (uri);
 632         } else
 633                 modest_account_mgr_add_server_account (priv->account_mgr, store_name, servername,
 634                                                        username, NULL, proto);
 635
 636         /* create server account -> transport */
 637         transport = MODEST_TRANSPORT_WIDGET(priv->transport_widget);
 638         proto = modest_transport_widget_get_proto (transport);
 639         username   = NULL;
 640         servername = NULL;
 641         if (proto == MODEST_PROTOCOL_TRANSPORT_SMTP) {
 642                 servername = modest_transport_widget_get_servername (transport);
 643                 if (modest_transport_widget_get_requires_auth (transport))
 644                         username = modest_transport_widget_get_username (transport);
 645         }
 646
 647         transport_name = get_new_server_account_name (priv->account_mgr, proto,username, servername);
 648         modest_account_mgr_add_server_account (priv->account_mgr,
 649                                                 transport_name, servername,
 650                                                 username, NULL,
 651                                                 proto);
 652
 653         /* create account */
 654         account_name = get_account_name (self);
 655         modest_account_mgr_add_account (priv->account_mgr,
 656                                         account_name,
 657                                         store_name,
 658                                         transport_name,
 659                                         NULL);
 660         modest_account_mgr_set_string (priv->account_mgr,
 661                                        account_name,
 662                                        MODEST_ACCOUNT_FULLNAME,
 663                                        get_fullname(self), FALSE, NULL);
 664         modest_account_mgr_set_string (priv->account_mgr,
 665                                        account_name,
 666                                        MODEST_ACCOUNT_EMAIL,
 667                                        get_email(self), FALSE, NULL);
 668
 669         /* Frees */
 670         g_free (store_name);
 671         g_free (transport_name);
 672 }
 673
 674
 675
 676 GtkWidget*
 677 modest_account_assistant_new (ModestAccountMgr *account_mgr, ModestWidgetFactory *factory)
 678 {
 679         GObject *obj;
 680         ModestAccountAssistant *self;
 681         ModestAccountAssistantPrivate *priv;
 682
 683         g_return_val_if_fail (factory, NULL);
 684         g_return_val_if_fail (account_mgr, NULL);
 685
 686         obj  = g_object_new(MODEST_TYPE_ACCOUNT_ASSISTANT, NULL);
 687         self = MODEST_ACCOUNT_ASSISTANT(obj);
 688
 689         priv = MODEST_ACCOUNT_ASSISTANT_GET_PRIVATE(self);
 690
 691         g_object_ref (factory);
 692         priv->factory = factory;
 693
 694         g_object_ref (account_mgr);
 695         priv->account_mgr = account_mgr;
 696
 697         add_intro_page (self);
 698         add_identity_page (self);
 699         add_receiving_page (self);
 700         add_sending_page (self);
 701         add_final_page (self);
 702
 703         gtk_assistant_set_current_page (GTK_ASSISTANT(self), 0);
 704         gtk_window_set_title (GTK_WINDOW(self),
 705                               _("Modest Account Wizard"));
 706         gtk_window_set_resizable (GTK_WINDOW(self), TRUE);
 707         gtk_window_set_default_size (GTK_WINDOW(self), 400, 400);
 708
 709         gtk_window_set_modal (GTK_WINDOW(self), TRUE);
 710
 711         g_signal_connect (G_OBJECT(self), "apply",
 712                           G_CALLBACK(on_apply), NULL);
 713         g_signal_connect (G_OBJECT(self), "cancel",
 714                           G_CALLBACK(on_cancel), NULL);
 715         g_signal_connect (G_OBJECT(self), "close",
 716                           G_CALLBACK(on_close), NULL);
 717
 718         return GTK_WIDGET(self);
 719 }