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