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