src/wizard.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2015 Colin Leroy <colin@colino.net>
   4  * and the Claws Mail team
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include "defs.h"
  26
  27 #include <glib.h>
  28 #include <glib/gi18n.h>
  29 #include <gdk/gdkkeysyms.h>
  30 #include <gtk/gtk.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36
  37 #include "utils.h"
  38 #include "gtk/menu.h"
  39 #include "plugin.h"
  40 #include "account.h"
  41 #include "prefs_account.h"
  42 #include "mainwindow.h"
  43 #include "stock_pixmap.h"
  44 #include "setup.h"
  45 #include "folder.h"
  46 #include "alertpanel.h"
  47 #include "filesel.h"
  48 #ifdef USE_GNUTLS
  49 #include "ssl.h"
  50 #endif
  51 #include "prefs_common.h"
  52 #include "combobox.h"
  53
  54 typedef enum
  55 {
  56         GO_BACK,
  57         GO_FORWARD,
  58         CANCEL,
  59         FINISHED
  60 } PageNavigation;
  61
  62 int WELCOME_PAGE = -1;
  63 int USER_PAGE = -1;
  64 int SMTP_PAGE = -1;
  65 int RECV_PAGE = -1;
  66 int MAILBOX_PAGE = -1;
  67 int DONE_PAGE = -1;
  68
  69 typedef struct
  70 {
  71         GtkWidget *window;
  72         GSList    *pages;
  73         GtkWidget *notebook;
  74
  75         MainWindow *mainwin;
  76
  77         GtkWidget *email;
  78         GtkWidget *full_name;
  79         GtkWidget *organization;
  80
  81         GtkWidget *mailbox_name;
  82         GtkWidget *mailbox_label;
  83
  84         GtkWidget *smtp_server;
  85         GtkWidget *smtp_auth;
  86         GtkWidget *smtp_username;
  87         GtkWidget *smtp_password;
  88         GtkWidget *smtp_username_label;
  89         GtkWidget *smtp_password_label;
  90
  91         GtkWidget *recv_type;
  92         GtkWidget *recv_label;
  93         GtkWidget *recv_server;
  94         GtkWidget *recv_username;
  95         GtkWidget *recv_password;
  96         GtkWidget *recv_username_label;
  97         GtkWidget *recv_password_label;
  98         GtkWidget *recv_imap_label;
  99         GtkWidget *recv_imap_subdir;
 100         GtkWidget *subsonly_checkbtn;
 101         GtkWidget *no_imap_warning;
 102 #ifdef USE_GNUTLS
 103         GtkWidget *smtp_use_ssl;
 104         GtkWidget *recv_use_ssl;
 105         GtkWidget *smtp_use_tls;
 106         GtkWidget *recv_use_tls;
 107         GtkWidget *smtp_ssl_cert_file;
 108         GtkWidget *recv_ssl_cert_file;
 109         GtkWidget *smtp_ssl_cert_pass;
 110         GtkWidget *recv_ssl_cert_pass;
 111         GtkWidget *smtp_cert_table;
 112         GtkWidget *recv_cert_table;
 113 #endif
 114 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
 115         GtkWidget *auto_configure_lbl;
 116         GtkWidget *auto_configure_btn;
 117         GtkWidget *auto_configure_cancel_btn;
 118 #endif
 119         gboolean create_mailbox;
 120         gboolean finished;
 121         gboolean result;
 122
 123 } WizardWindow;
 124
 125 typedef struct _AccountTemplate {
 126         gchar *name;
 127         gchar *domain;
 128         gchar *email;
 129         gchar *organization;
 130         gchar *smtpserver;
 131         gboolean smtpauth;
 132         gchar *smtpuser;
 133         gchar *smtppass;
 134         RecvProtocol recvtype;
 135         gchar *recvserver;
 136         gchar *recvuser;
 137         gchar *recvpass;
 138         gchar *imapdir;
 139         gboolean subsonly;
 140         gchar *mboxfile;
 141         gchar *mailbox;
 142         gboolean smtpssl;
 143         gboolean recvssl;
 144         gchar *smtpssl_cert;
 145         gchar *recvssl_cert;
 146         gchar *smtpssl_cert_pass;
 147         gchar *recvssl_cert_pass;
 148 } AccountTemplate;
 149
 150 static AccountTemplate tmpl;
 151
 152 static PrefParam template_params[] = {
 153         {"name", "$USERNAME",
 154          &tmpl.name, P_STRING, NULL, NULL, NULL},
 155         {"domain", "$DEFAULTDOMAIN",
 156          &tmpl.domain, P_STRING, NULL, NULL, NULL},
 157         {"email", "$NAME_MAIL@$DOMAIN",
 158          &tmpl.email, P_STRING, NULL, NULL, NULL},
 159         {"organization", "",
 160          &tmpl.organization, P_STRING, NULL, NULL, NULL},
 161         {"smtpserver", "smtp.$DOMAIN",
 162          &tmpl.smtpserver, P_STRING, NULL, NULL, NULL},
 163         {"smtpauth", "FALSE",
 164          &tmpl.smtpauth, P_BOOL, NULL, NULL, NULL},
 165         {"smtpuser", "",
 166          &tmpl.smtpuser, P_STRING, NULL, NULL, NULL},
 167         {"smtppass", "",
 168          &tmpl.smtppass, P_STRING, NULL, NULL, NULL},
 169         {"recvtype", A_POP3,
 170          &tmpl.recvtype, P_INT, NULL, NULL, NULL},
 171         {"recvserver", "pop.$DOMAIN",
 172          &tmpl.recvserver, P_STRING, NULL, NULL, NULL},
 173         {"recvuser", "$LOGIN",
 174          &tmpl.recvuser, P_STRING, NULL, NULL, NULL},
 175         {"recvpass", "",
 176          &tmpl.recvpass, P_STRING, NULL, NULL, NULL},
 177         {"imapdir", "",
 178          &tmpl.imapdir, P_STRING, NULL, NULL, NULL},
 179         {"subsonly", "TRUE",
 180          &tmpl.subsonly, P_BOOL, NULL, NULL, NULL},
 181         {"mboxfile", "/var/mail/$LOGIN",
 182          &tmpl.mboxfile, P_STRING, NULL, NULL, NULL},
 183         {"mailbox", "Mail",
 184          &tmpl.mailbox, P_STRING, NULL, NULL, NULL},
 185         {"smtpssl", "0",
 186          &tmpl.smtpssl, P_INT, NULL, NULL, NULL},
 187         {"recvssl", "0",
 188          &tmpl.recvssl, P_INT, NULL, NULL, NULL},
 189         {"smtpssl_cert", "",
 190          &tmpl.smtpssl_cert, P_STRING, NULL, NULL, NULL},
 191         {"recvssl_cert", "",
 192          &tmpl.recvssl_cert, P_STRING, NULL, NULL, NULL},
 193         {"smtpssl_cert_pass", "",
 194          &tmpl.smtpssl_cert, P_STRING, NULL, NULL, NULL},
 195         {"recvssl_cert_pass", "",
 196          &tmpl.recvssl_cert, P_STRING, NULL, NULL, NULL},
 197         {NULL, NULL, NULL, P_INT, NULL, NULL, NULL}
 198 };
 199
 200
 201 static gchar *accountrc_tmpl =
 202         "[AccountTemplate]\n"
 203         "#you can use $DEFAULTDOMAIN here\n"
 204         "#domain must be defined before the variables that use it\n"
 205         "#by default, domain is extracted from the hostname\n"
 206         "#domain=\n"
 207         "\n"
 208         "#you can use $USERNAME for name (this is the default)\n"
 209         "#name=\n"
 210         "\n"
 211         "#you can use $LOGIN, $NAME_MAIL and $DOMAIN here \n"
 212         "#$NAME_MAIL is the name without uppercase and with dots instead\n"
 213         "#of spaces\n"
 214         "#the default is $NAME_MAIL@$DOMAIN\n"
 215         "#email=\n"
 216         "\n"
 217         "#you can use $DOMAIN here\n"
 218         "#the default organization is empty\n"
 219         "#organization=\n"
 220         "\n"
 221         "#you can use $DOMAIN here \n"
 222         "#the default is smtp.$DOMAIN\n"
 223         "#smtpserver=\n"
 224         "\n"
 225         "#Whether to use smtp authentication\n"
 226         "#the default is 0 (no)\n"
 227         "#smtpauth=\n"
 228         "\n"
 229         "#SMTP username\n"
 230         "#you can use $LOGIN, $NAME_MAIL, $DOMAIN or $EMAIL here\n"
 231         "#the default is empty (same as reception username)\n"
 232         "#smtpuser=\n"
 233         "\n"
 234         "#SMTP password\n"
 235         "#the default is empty (same as reception password)\n"
 236         "#smtppass=\n"
 237         "\n"
 238         "#recvtype can be:\n"
 239         "#0 for pop3\n"
 240         "#3  for imap\n"
 241         "#5  for a local mbox file\n"
 242         "#recvtype=\n"
 243         "\n"
 244         "#you can use $DOMAIN here \n"
 245         "#the default is {pop,imap}.$DOMAIN\n"
 246         "#recvserver=\n"
 247         "\n"
 248         "#you can use $LOGIN, $NAME_MAIL, $DOMAIN or $EMAIL here\n"
 249         "#default is $LOGIN\n"
 250         "#recvuser=\n"
 251         "\n"
 252         "#default is empty\n"
 253         "#recvpass=\n"
 254         "\n"
 255         "#imap dir if imap (relative to the home on the server)\n"
 256         "#default is empty\n"
 257         "#imapdir=\n"
 258         "\n"
 259         "#show subscribed folders only, if imap\n"
 260         "#default is TRUE\n"
 261         "#subsonly=\n"
 262         "\n"
 263         "#mbox file if local\n"
 264         "#you can use $LOGIN here\n"
 265         "#default is /var/mail/$LOGIN\n"
 266         "#mboxfile=\n"
 267         "\n"
 268         "#mailbox name if pop3 or local\n"
 269         "#relative path from the user's home\n"
 270         "#default is \"Mail\"\n"
 271         "#mailbox=\n"
 272         "\n"
 273         "#whether to use ssl on smtp connections\n"
 274         "#default is 0, 1 is ssl, 2 is starttls\n"
 275         "#smtpssl=\n"
 276         "\n"
 277         "#whether to use ssl on pop or imap connections\n"
 278         "#default is 0, 1 is ssl, 2 is starttls\n"
 279         "#recvssl=\n"
 280         "\n"
 281         "#SSL client certificate path for SMTP\n"
 282         "#default is empty (no certificate)\n"
 283         "#smtpssl_cert=\n"
 284         "\n"
 285         "#SSL client certificate path for POP/IMAP\n"
 286         "#default is empty (no certificate)\n"
 287         "#recvssl_cert=\n"
 288         "\n"
 289         "#SSL client certificate password for SMTP\n"
 290         "#default is empty (no password)\n"
 291         "#smtpssl_cert_pass=\n"
 292         "\n"
 293         "#SSL client certificate password for POP/IMAP\n"
 294         "#default is empty (no password)\n"
 295         "#recvssl_cert_pass=\n"
 296         ;
 297
 298 static gchar *wizard_get_default_domain_name(void)
 299 {
 300         static gchar *domain_name = NULL;
 301
 302         if (domain_name == NULL) {
 303                 domain_name = g_strdup(get_domain_name());
 304                 if (strchr(domain_name, '.') != NULL
 305                 && strchr(domain_name, '.') != strrchr(domain_name, '.')
 306                 && strlen(strchr(domain_name, '.')) > 6) {
 307                         gchar *tmp = g_strdup(strchr(domain_name, '.')+1);
 308                         g_free(domain_name);
 309                         domain_name = tmp;
 310                 }
 311         }
 312         return domain_name;
 313 }
 314
 315 static gchar *get_name_for_mail(void)
 316 {
 317         gchar *name = NULL;
 318         if (tmpl.name == NULL)
 319                 return NULL;
 320         name = g_utf8_strdown(tmpl.name, -1);
 321         while(strstr(name, " "))
 322                 *strstr(name, " ")='.';
 323
 324         return name;
 325 }
 326
 327 #define PARSE_DEFAULT(str) {    \
 328         gchar *tmp = NULL, *new = NULL; \
 329         if (str != NULL) {      \
 330                 if (strstr(str, "$USERNAME")) { \
 331                         tmp = g_strdup(str); \
 332                         *strstr(tmp, "$USERNAME") = '\0';       \
 333                         new = g_strconcat(tmp, g_get_real_name(),       \
 334                                 strstr(str, "$USERNAME")+strlen("$USERNAME"),   \
 335                                 NULL);  \
 336                         g_free(tmp);    \
 337                         g_free(str);    \
 338                         str = new;      \
 339                         new = NULL;     \
 340                 }       \
 341                 if (strstr(str, "$LOGIN")) {    \
 342                         tmp = g_strdup(str); \
 343                         *strstr(tmp, "$LOGIN") = '\0';  \
 344                         new = g_strconcat(tmp, g_get_user_name(),       \
 345                                 strstr(str, "$LOGIN")+strlen("$LOGIN"),         \
 346                                 NULL);  \
 347                         g_free(tmp);    \
 348                         g_free(str);    \
 349                         str = new;      \
 350                         new = NULL;     \
 351                 }       \
 352                 if (strstr(str, "$EMAIL")) {    \
 353                         tmp = g_strdup(str); \
 354                         *strstr(tmp, "$EMAIL") = '\0';  \
 355                         new = g_strconcat(tmp, tmpl.email,      \
 356                                 strstr(str, "$EMAIL")+strlen("$EMAIL"),         \
 357                                 NULL);  \
 358                         g_free(tmp);    \
 359                         g_free(str);    \
 360                         str = new;      \
 361                         new = NULL;     \
 362                 }       \
 363                 if (strstr(str, "$NAME_MAIL")) {        \
 364                         tmp = g_strdup(str); \
 365                         *strstr(tmp, "$NAME_MAIL") = '\0';      \
 366                         new = g_strconcat(tmp, get_name_for_mail(),     \
 367                                 strstr(str, "$NAME_MAIL")+strlen("$NAME_MAIL"),         \
 368                                 NULL);  \
 369                         g_free(tmp);    \
 370                         g_free(str);    \
 371                         str = new;      \
 372                         new = NULL;     \
 373                 }       \
 374                 if (strstr(str, "$DEFAULTDOMAIN")) {    \
 375                         tmp = g_strdup(str); \
 376                         *strstr(tmp, "$DEFAULTDOMAIN") = '\0';  \
 377                         new = g_strconcat(tmp, wizard_get_default_domain_name(),        \
 378                                 strstr(str, "$DEFAULTDOMAIN")+strlen("$DEFAULTDOMAIN"),         \
 379                                 NULL);  \
 380                         g_free(tmp);    \
 381                         g_free(str);    \
 382                         str = new;      \
 383                         new = NULL;     \
 384                 }       \
 385                 if (strstr(str, "$DOMAIN")) {   \
 386                         tmp = g_strdup(str); \
 387                         *strstr(tmp, "$DOMAIN") = '\0'; \
 388                         new = g_strconcat(tmp, tmpl.domain,     \
 389                                 strstr(str, "$DOMAIN")+strlen("$DOMAIN"),       \
 390                                 NULL);  \
 391                         g_free(tmp);    \
 392                         g_free(str);    \
 393                         str = new;      \
 394                         new = NULL;     \
 395                 }       \
 396         }       \
 397 }
 398 static void wizard_read_defaults(void)
 399 {
 400         gchar *rcpath;
 401
 402         rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "accountrc.tmpl", NULL);
 403         if (!is_file_exist(rcpath)) {
 404                 str_write_to_file(accountrc_tmpl, rcpath);
 405         }
 406
 407         prefs_read_config(template_params, "AccountTemplate", rcpath, NULL);
 408
 409         PARSE_DEFAULT(tmpl.domain);
 410         PARSE_DEFAULT(tmpl.name);
 411         PARSE_DEFAULT(tmpl.email);
 412         PARSE_DEFAULT(tmpl.organization);
 413         PARSE_DEFAULT(tmpl.smtpserver);
 414         PARSE_DEFAULT(tmpl.smtpuser);
 415         PARSE_DEFAULT(tmpl.smtppass);
 416         PARSE_DEFAULT(tmpl.recvserver);
 417         PARSE_DEFAULT(tmpl.recvuser);
 418         PARSE_DEFAULT(tmpl.recvpass);
 419         PARSE_DEFAULT(tmpl.imapdir);
 420         PARSE_DEFAULT(tmpl.mboxfile);
 421         PARSE_DEFAULT(tmpl.mailbox);
 422 /*
 423         g_print("defaults:"
 424         "%s, %s, %s, %s, %s, %d, %s, %s, %s, %s, %s, %s, %d, %d\n",
 425         tmpl.name,tmpl.domain,tmpl.email,tmpl.organization,tmpl.smtpserver,
 426         tmpl.recvtype,tmpl.recvserver,tmpl.recvuser,tmpl.recvpass,
 427         tmpl.imapdir,tmpl.mboxfile,tmpl.mailbox,tmpl.smtpssl,tmpl.recvssl);
 428 */
 429         g_free(rcpath);
 430 }
 431
 432 static void initialize_fonts(WizardWindow *wizard)
 433 {
 434         GtkWidget *widget = wizard->email;
 435         gint size = pango_font_description_get_size(
 436                         gtk_widget_get_style(widget)->font_desc)
 437                       /PANGO_SCALE;
 438         gchar *tmp, *new;
 439 #ifdef G_OS_WIN32
 440         PangoFontDescription *bold_desc;
 441         gchar *curfont = pango_font_description_to_string(widget->style->font_desc);
 442         g_free(prefs_common.smallfont);
 443         g_free(prefs_common.normalfont);
 444         g_free(prefs_common.boldfont);
 445         prefs_common.smallfont = g_strdup(curfont);
 446         prefs_common.normalfont = g_strdup(curfont);
 447         bold_desc = pango_font_description_from_string(curfont);
 448         pango_font_description_set_weight(bold_desc, PANGO_WEIGHT_BOLD);
 449         prefs_common.boldfont = pango_font_description_to_string(bold_desc);
 450         pango_font_description_free(bold_desc);
 451         g_free(curfont);
 452 #endif
 453         tmp = g_strdup(prefs_common.textfont);
 454         if (strrchr(tmp, ' ')) {
 455                 *(strrchr(tmp, ' ')) = '\0';
 456                 new = g_strdup_printf("%s %d", tmp, size);
 457                 g_free(prefs_common.textfont);
 458                 prefs_common.textfont = new;
 459         }
 460         g_free(tmp);
 461
 462         tmp = g_strdup(prefs_common.smallfont);
 463         if (strrchr(tmp, ' ')) {
 464                 *(strrchr(tmp, ' ')) = '\0';
 465                 new = g_strdup_printf("%s %d", tmp, size);
 466                 g_free(prefs_common.smallfont);
 467                 prefs_common.smallfont = new;
 468         }
 469         g_free(tmp);
 470
 471         tmp = g_strdup(prefs_common.normalfont);
 472         if (strrchr(tmp, ' ')) {
 473                 *(strrchr(tmp, ' ')) = '\0';
 474                 new = g_strdup_printf("%s %d", tmp, size);
 475                 g_free(prefs_common.normalfont);
 476                 prefs_common.normalfont = new;
 477         }
 478         g_free(tmp);
 479
 480         tmp = g_strdup(prefs_common.boldfont);
 481         if (strrchr(tmp, ' ')) {
 482                 *(strrchr(tmp, ' ')) = '\0';
 483                 new = g_strdup_printf("%s %d", tmp, size);
 484                 g_free(prefs_common.boldfont);
 485                 prefs_common.boldfont = new;
 486         }
 487         g_free(tmp);
 488 }
 489
 490 #define XFACE "+}Axz@~a,-Yx?0Ysa|q}CLRH=89Y]\"')DSX^<6p\"d)'81yx5%G#u^o*7JG&[aPU0h1Ux.vb2yIjH83{5`/bVo|~nn/i83vE^E)qk-4W)_E.4Y=D*qvf/,Ci_=P<iY<M6"
 491 #define FACE "iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAMAAABg3Am1AAAAM1BMVEUAAAAcJCI\n\
 492  ONl1JUi0+Z4daY2NZciPabV9ykS5kj6Wsl2ybmZOBsMjZxK2wzN3Pzczs7OsCAGN0AAAAAXRSTlM\n\
 493  AQObYZgAAAAFiS0dEAIgFHUgAAAIVSURBVEjH1ZbtlqMgDIaFECoGhPu/2s0b0Lais/NzN6d1OJ7\n\
 494  3yReQzrL8B5Zy3rvl9At52Pf2tv1vSMjtYj8jaa8XUyI/yn3YD6sigj/2Tf5Bn069MIsTPHvx/t5\n\
 495  /3rU/6JCIY3YwGe26r/cwUfE3cFe5T28L0K5rJAUHEeYAQxs8DHojjk3M9wECU4xxjXisI8RA0gy\n\
 496  oczJZJOjxiTFZVTchAnIRJrgdmEGDyFfAI3UuG5FmYTkR9RDrIC4H0SqV4pzpEcUp0HNLjwBv+jA\n\
 497  dikUE5g9iBvzmu3sH2oDk4lnHd829+2Q9gj6kDqDPg7hsGwBzH02fE3ZCt6ZHmlNKIMjMeRwra5I\n\
 498  ecgNoBnLGPmzaHPJIwLY8Sq2M/tLUJfj0QcqmfVXAdLSStIYF8dzWjBBb2VgvDa4mO9oc651OiUo\n\
 499  BEKbZokdPATF9E9oKAjQJcJOniaPXrVZRAnVWaqIyqRoNC8ZJvgCcW8XN39RqxVP1rS8Yd4WnCdN\n\
 500  aRTo2jJRDbg3vtCpEUGffgDPhqKDaSuVqYtOplFIvIcx3HUI5/MuIWl6vKyBjNlqEru8hbFXqBPA\n\
 501  5TpHGIUZOePeaIyzfQ/g9Xg0opU1AvdfXM9floYhv92pPAE96OZtkPV8eivgQi9RTfwPUU36I26n\n\
 502  Hy+WuCJzAT7efMSeA1TNf2/VugDz+dN139xfA5ffxGZDD+MvcP/uvyB80wzZ76wbz8gAAAABJRU5\n\
 503  ErkJggg=="
 504
 505 static void write_welcome_email(WizardWindow *wizard)
 506 {
 507         gchar buf_date[64];
 508         gchar *head=NULL;
 509         gchar *body=NULL;
 510         gchar *msg=NULL;
 511         const gchar *mailbox = gtk_entry_get_text(GTK_ENTRY(wizard->mailbox_name));
 512         Folder *folder = folder_find_from_path(mailbox);
 513         FolderItem *inbox = folder ? folder->inbox:NULL;
 514         gchar *file = get_tmp_file();
 515         gchar enc_from_name[BUFFSIZE], enc_to_name[BUFFSIZE], enc_subject[BUFFSIZE];
 516
 517         get_rfc822_date(buf_date, sizeof(buf_date));
 518
 519         conv_encode_header_full(enc_subject, sizeof(enc_subject),
 520                         C_("Welcome Mail Subject", "Welcome to Claws Mail"),
 521                         strlen("Subject: "), FALSE, CS_INTERNAL);
 522         conv_encode_header_full(enc_to_name, sizeof(enc_to_name),
 523                         gtk_entry_get_text(GTK_ENTRY(wizard->full_name)),
 524                         strlen("To: "), TRUE, CS_INTERNAL);
 525         conv_encode_header_full(enc_from_name, sizeof(enc_from_name),
 526                         _("The Claws Mail Team"),
 527                         strlen("From: "), TRUE, CS_INTERNAL);
 528
 529         head = g_strdup_printf(
 530                 "From: %s <%s>\n"
 531                 "To: %s <%s>\n"
 532                 "Date: %s\n"
 533                 "Subject: %s\n"
 534                 "X-Face: %s\n"
 535                 "Face: %s\n"
 536                 "Content-Type: text/plain; charset=UTF-8\n",
 537                 enc_from_name,
 538                 USERS_ML_ADDR,
 539                 enc_to_name,
 540                 gtk_entry_get_text(GTK_ENTRY(wizard->email)),
 541                 buf_date, enc_subject, XFACE, FACE);
 542         body = g_strdup_printf(
 543                 _("\n"
 544                 "Welcome to Claws Mail\n"
 545                 "---------------------\n"
 546                 "\n"
 547                 "Now that you have set up your account you can fetch your\n"
 548                 "mail by clicking the 'Get Mail' button at the left of the\n"
 549                 "toolbar.\n"
 550                 "\n"
 551                 "Claws Mail has lots of extra features accessible via plugins,\n"
 552                 "like anti-spam filtering and learning (via the Bogofilter or\n"
 553                 "SpamAssassin plugins), privacy protection (via PGP/Mime), an RSS\n"
 554                 "aggregator, a calendar, and much more. You can load them from\n"
 555                 "the menu entry '/Configuration/Plugins'.\n"
 556                 "\n"
 557                 "You can change your Account Preferences by using the menu\n"
 558                 "entry '/Configuration/Preferences for current account'\n"
 559                 "and change the general Preferences by using\n"
 560                 "'/Configuration/Preferences'.\n"
 561                 "\n"
 562                 "You can find further information in the Claws Mail manual,\n"
 563                 "which can be accessed by using the menu entry '/Help/Manual'\n"
 564                 "or online at the URL given below.\n"
 565                 "\n"
 566                 "Useful URLs\n"
 567                 "-----------\n"
 568                 "Homepage:      <%s>\n"
 569                 "Manual:        <%s>\n"
 570                 "FAQ:          <%s>\n"
 571                 "Themes:        <%s>\n"
 572                 "Mailing Lists: <%s>\n"
 573                 "\n"
 574                 "LICENSE\n"
 575                 "-------\n"
 576                 "Claws Mail is free software, released under the terms\n"
 577                 "of the GNU General Public License, version 3 or later, as\n"
 578                 "published by the Free Software Foundation, 51 Franklin Street,\n"
 579                 "Fifth Floor, Boston, MA 02110-1301, USA. The license can be\n"
 580                 "found at <%s>.\n"
 581                 "\n"
 582                 "DONATIONS\n"
 583                 "---------\n"
 584                 "If you wish to donate to the Claws Mail project you can do\n"
 585                 "so at <%s>.\n\n"),
 586                 HOMEPAGE_URI, MANUAL_URI, FAQ_URI, THEMES_URI, MAILING_LIST_URI,
 587                 GPL_URI, DONATE_URI);
 588
 589         msg = g_strconcat(head, body, NULL);
 590
 591         if (inbox && inbox->total_msgs == 0
 592          && str_write_to_file(msg, file) >= 0) {
 593                 MsgFlags flags = { MSG_UNREAD|MSG_NEW, 0};
 594                 folder_item_add_msg(inbox, file, &flags, FALSE);
 595         }
 596         g_free(head);
 597         g_free(body);
 598         g_free(msg);
 599         claws_unlink(file);
 600 }
 601 #undef XFACE
 602
 603 static gboolean wizard_write_config(WizardWindow *wizard)
 604 {
 605         static gboolean mailbox_ok = FALSE;
 606         PrefsAccount *prefs_account = prefs_account_new();
 607         GList *account_list = NULL;
 608         gchar *smtp_server, *recv_server;
 609         gint smtp_port, recv_port;
 610 #ifdef USE_GNUTLS
 611         SSLType smtp_ssl_type, recv_ssl_type;
 612 #endif
 613
 614         prefs_account->protocol = combobox_get_active_data(
 615                                         GTK_COMBO_BOX(wizard->recv_type));
 616
 617         if (wizard->create_mailbox && prefs_account->protocol != A_IMAP4 &&
 618             !strlen(gtk_entry_get_text(GTK_ENTRY(wizard->mailbox_name)))) {
 619                 alertpanel_error(_("Please enter the mailbox name."));
 620                 g_free(prefs_account);
 621                 gtk_notebook_set_current_page (
 622                         GTK_NOTEBOOK(wizard->notebook),
 623                         MAILBOX_PAGE);
 624                 return FALSE;
 625         }
 626
 627         if (!mailbox_ok) {
 628                 if (wizard->create_mailbox && prefs_account->protocol != A_IMAP4) {
 629                         mailbox_ok = setup_write_mailbox_path(wizard->mainwin,
 630                                         gtk_entry_get_text(
 631                                                 GTK_ENTRY(wizard->mailbox_name)));
 632                 } else
 633                         mailbox_ok = TRUE;
 634         }
 635
 636         if (!mailbox_ok) {
 637                 /* alertpanel done by setup_write_mailbox_path */
 638                 g_free(prefs_account);
 639                 gtk_notebook_set_current_page (
 640                         GTK_NOTEBOOK(wizard->notebook),
 641                         MAILBOX_PAGE);
 642                 return FALSE;
 643         }
 644
 645         if (!strlen(gtk_entry_get_text(GTK_ENTRY(wizard->full_name)))
 646         ||  !strlen(gtk_entry_get_text(GTK_ENTRY(wizard->email)))) {
 647                 alertpanel_error(_("Please enter your name and email address."));
 648                 g_free(prefs_account);
 649                 gtk_notebook_set_current_page (
 650                         GTK_NOTEBOOK(wizard->notebook),
 651                         USER_PAGE);
 652                 return FALSE;
 653         }
 654
 655         if (prefs_account->protocol != A_LOCAL) {
 656                 if (!strlen(gtk_entry_get_text(GTK_ENTRY(wizard->recv_username)))
 657                 ||  !strlen(gtk_entry_get_text(GTK_ENTRY(wizard->recv_server)))) {
 658                         alertpanel_error(_("Please enter your receiving server "
 659                                            "and username."));
 660                         g_free(prefs_account);
 661                         gtk_notebook_set_current_page (
 662                                 GTK_NOTEBOOK(wizard->notebook),
 663                                 RECV_PAGE);
 664                         return FALSE;
 665                 }
 666         } else {
 667                 if (!strlen(gtk_entry_get_text(GTK_ENTRY(wizard->recv_server)))) {
 668                         alertpanel_error(_("Please enter your username."));
 669                         g_free(prefs_account);
 670                         gtk_notebook_set_current_page (
 671                                 GTK_NOTEBOOK(wizard->notebook),
 672                                 RECV_PAGE);
 673                         return FALSE;
 674                 }
 675         }
 676
 677         if (!strlen(gtk_entry_get_text(GTK_ENTRY(wizard->smtp_server)))) {
 678                 alertpanel_error(_("Please enter your SMTP server."));
 679                 g_free(prefs_account);
 680                 gtk_notebook_set_current_page (
 681                         GTK_NOTEBOOK(wizard->notebook),
 682                         SMTP_PAGE);
 683                 return FALSE;
 684         }
 685
 686         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_auth))) {
 687                 if (prefs_account->protocol == A_LOCAL
 688                 &&  !strlen(gtk_entry_get_text(GTK_ENTRY(wizard->smtp_username)))) {
 689                         alertpanel_error(_("Please enter your SMTP username."));
 690                         g_free(prefs_account);
 691                         gtk_notebook_set_current_page (
 692                                 GTK_NOTEBOOK(wizard->notebook),
 693                                 SMTP_PAGE);
 694                         return FALSE;
 695                 } /* if it's not local we'll use the reception server */
 696         }
 697
 698         if (prefs_account->protocol != A_LOCAL)
 699                 prefs_account->account_name = g_strdup_printf("%s@%s",
 700                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_username)),
 701                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_server)));
 702         else
 703                 prefs_account->account_name = g_strdup_printf("%s",
 704                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_server)));
 705
 706         recv_server = g_strdup(gtk_entry_get_text(GTK_ENTRY(wizard->recv_server)));
 707         smtp_server = g_strdup(gtk_entry_get_text(GTK_ENTRY(wizard->smtp_server)));
 708
 709         if (prefs_account->protocol != A_LOCAL && strstr(recv_server, ":")) {
 710                 recv_port = atoi(strstr(recv_server, ":")+1);
 711                 *(strstr(recv_server, ":")) = '\0';
 712                 if (prefs_account->protocol == A_IMAP4) {
 713                         prefs_account->set_imapport = TRUE;
 714                         prefs_account->imapport = recv_port;
 715                 } else if (prefs_account->protocol == A_POP3) {
 716                         prefs_account->set_popport = TRUE;
 717                         prefs_account->popport = recv_port;
 718                 }
 719         }
 720         if (strstr(smtp_server, ":")) {
 721                 smtp_port = atoi(strstr(smtp_server, ":")+1);
 722                 *(strstr(smtp_server, ":")) = '\0';
 723                 prefs_account->set_smtpport = TRUE;
 724                 prefs_account->smtpport = smtp_port;
 725         }
 726
 727         prefs_account->name = g_strdup(
 728                                 gtk_entry_get_text(GTK_ENTRY(wizard->full_name)));
 729         prefs_account->address = g_strdup(
 730                                 gtk_entry_get_text(GTK_ENTRY(wizard->email)));
 731         prefs_account->organization = g_strdup(
 732                                 gtk_entry_get_text(GTK_ENTRY(wizard->organization)));
 733         prefs_account->smtp_server = g_strdup(smtp_server);
 734
 735         if (wizard->create_mailbox && prefs_account->protocol != A_IMAP4) {
 736                 gchar *tmp;
 737                 tmp = g_path_get_basename(gtk_entry_get_text(GTK_ENTRY(wizard->mailbox_name)));
 738                 prefs_account->inbox = g_strdup_printf("#mh/%s/inbox",
 739                         (!strcmp("Mail", gtk_entry_get_text(GTK_ENTRY(wizard->mailbox_name))))
 740                                 ?_("Mailbox"):tmp);
 741                 g_free(tmp);
 742                 prefs_account->local_inbox = g_strdup(prefs_account->inbox);
 743         } else if (prefs_account->protocol != A_IMAP4) {
 744                 if (folder_get_default_inbox())
 745                         prefs_account->local_inbox =
 746                                 folder_item_get_identifier(folder_get_default_inbox());
 747         }
 748
 749         if (prefs_account->protocol != A_LOCAL)
 750                 prefs_account->recv_server = g_strdup(recv_server);
 751         else
 752                 prefs_account->local_mbox = g_strdup(recv_server);
 753
 754         g_free(recv_server);
 755         g_free(smtp_server);
 756
 757         prefs_account->userid = g_strdup(
 758                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_username)));
 759         prefs_account->passwd = g_strdup(
 760                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_password)));
 761
 762         prefs_account->smtp_userid = g_strdup(
 763                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_username)));
 764         prefs_account->smtp_passwd = g_strdup(
 765                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_password)));
 766         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_auth))) {
 767                 prefs_account->use_smtp_auth = TRUE;
 768         }
 769
 770 #ifdef USE_GNUTLS
 771         smtp_ssl_type = SSL_NONE;
 772         recv_ssl_type = SSL_NONE;
 773
 774         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl))) {
 775                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_tls)))
 776                         smtp_ssl_type = SSL_STARTTLS;
 777                 else
 778                         smtp_ssl_type = SSL_TUNNEL;
 779         }
 780         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->recv_use_ssl))) {
 781                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->recv_use_tls)))
 782                         recv_ssl_type = SSL_STARTTLS;
 783                 else
 784                         recv_ssl_type = SSL_TUNNEL;
 785         }
 786
 787         prefs_account->ssl_smtp = smtp_ssl_type;
 788
 789         if (prefs_account->protocol == A_IMAP4)
 790                 prefs_account->ssl_imap = recv_ssl_type;
 791         else
 792                 prefs_account->ssl_pop = recv_ssl_type;
 793
 794         prefs_account->out_ssl_client_cert_file = g_strdup(
 795                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_ssl_cert_file)));
 796         prefs_account->out_ssl_client_cert_pass = g_strdup(
 797                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_ssl_cert_pass)));
 798         prefs_account->in_ssl_client_cert_file = g_strdup(
 799                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_ssl_cert_file)));
 800         prefs_account->in_ssl_client_cert_pass = g_strdup(
 801                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_ssl_cert_pass)));
 802 #endif
 803         if (prefs_account->protocol == A_IMAP4) {
 804                 gchar *directory = gtk_editable_get_chars(
 805                         GTK_EDITABLE(wizard->recv_imap_subdir), 0, -1);
 806                 if (directory && strlen(directory)) {
 807                         prefs_account->imap_dir = g_strdup(directory);
 808                 }
 809                 prefs_account->imap_subsonly =
 810                         gtk_toggle_button_get_active(
 811                                 GTK_TOGGLE_BUTTON(wizard->subsonly_checkbtn));
 812                 g_free(directory);
 813         }
 814
 815         account_list = g_list_append(account_list, prefs_account);
 816         prefs_account_write_config_all(account_list);
 817         prefs_account_free(prefs_account);
 818         account_read_config_all();
 819
 820         initialize_fonts(wizard);
 821         if (wizard->create_mailbox && prefs_account->protocol != A_IMAP4)
 822                 write_welcome_email(wizard);
 823
 824 #ifndef G_OS_WIN32
 825         plugin_load_standard_plugins();
 826 #endif
 827         return TRUE;
 828 }
 829
 830 static GtkWidget* create_page (WizardWindow *wizard, const char * title)
 831 {
 832         GtkWidget *w;
 833         GtkWidget *vbox;
 834         GtkWidget *hbox;
 835         GtkWidget *image;
 836         char *title_string;
 837
 838         vbox = gtk_vbox_new (FALSE, 6);
 839         gtk_container_set_border_width  (GTK_CONTAINER(vbox), 10);
 840
 841         /* create the titlebar */
 842         hbox = gtk_hbox_new (FALSE, 12);
 843         image = stock_pixmap_widget(wizard->window,
 844                                 STOCK_PIXMAP_CLAWS_MAIL_ICON);
 845         gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 0);
 846         title_string = g_strconcat ("<span size=\"xx-large\" weight=\"ultrabold\">", title ? title : "", "</span>", NULL);
 847         w = gtk_label_new (title_string);
 848         gtk_label_set_use_markup (GTK_LABEL(w), TRUE);
 849         g_free (title_string);
 850         gtk_box_pack_start (GTK_BOX(hbox), w, FALSE, FALSE, 0);
 851
 852         /* pack the titlebar */
 853         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 854
 855         /* pack the separator */
 856         gtk_box_pack_start (GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
 857
 858         /* pack space */
 859         w = gtk_alignment_new (0, 0, 0, 0);
 860         gtk_widget_set_size_request (w, 0, 6);
 861         gtk_box_pack_start (GTK_BOX(vbox), w, FALSE, FALSE, 0);
 862
 863         return vbox;
 864 }
 865
 866 #define PACK_BOX(hbox,text,entry) {                                     \
 867         GtkWidget *label = gtk_label_new(text);                         \
 868         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);               \
 869         if (GTK_IS_MISC(label))                                         \
 870                 gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);        \
 871         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);      \
 872         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);        \
 873 }
 874
 875 static gchar *get_default_server(WizardWindow * wizard, const gchar *type)
 876 {
 877         if (!strcmp(type, "smtp")) {
 878                 if (!tmpl.smtpserver || !strlen(tmpl.smtpserver))
 879                         return g_strconcat(type, ".", tmpl.domain, NULL);
 880                 else
 881                         return g_strdup(tmpl.smtpserver);
 882         } else {
 883                 if (!tmpl.recvserver || !strlen(tmpl.recvserver))
 884                         return g_strconcat(type, ".", tmpl.domain, NULL);
 885                 else
 886                         return g_strdup(tmpl.recvserver);
 887         }
 888 }
 889
 890 static gchar *get_default_account(WizardWindow * wizard)
 891 {
 892         gchar *result = NULL;
 893
 894         if (!tmpl.recvuser || !strlen(tmpl.recvuser)) {
 895                 result = gtk_editable_get_chars(
 896                                 GTK_EDITABLE(wizard->email), 0, -1);
 897
 898                 if (strstr(result, "@")) {
 899                         *(strstr(result,"@")) = '\0';
 900                 }
 901         } else {
 902                 result = g_strdup(tmpl.recvuser);
 903         }
 904         return result;
 905 }
 906
 907 static gchar *get_default_smtp_account(WizardWindow * wizard)
 908 {
 909         gchar *result = NULL;
 910
 911         if (!tmpl.smtpuser || !strlen(tmpl.smtpuser)) {
 912                 return g_strdup("");
 913         } else {
 914                 result = g_strdup(tmpl.smtpuser);
 915         }
 916         return result;
 917 }
 918
 919 static void wizard_email_changed(GtkWidget *widget, gpointer data)
 920 {
 921         WizardWindow *wizard = (WizardWindow *)data;
 922         RecvProtocol protocol;
 923         gchar *text;
 924         protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
 925
 926         text = get_default_server(wizard, "smtp");
 927         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_server), text);
 928         g_free(text);
 929
 930         text = get_default_account(wizard);
 931         gtk_entry_set_text(GTK_ENTRY(wizard->recv_username), text);
 932         g_free(text);
 933
 934         if (protocol == A_POP3) {
 935                 text = get_default_server(wizard, "pop");
 936                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
 937                 g_free(text);
 938         } else if (protocol == A_IMAP4) {
 939                 text = get_default_server(wizard, "imap");
 940                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
 941                 g_free(text);
 942         } else if (protocol == A_LOCAL) {
 943                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), tmpl.mboxfile?tmpl.mboxfile:"");
 944         }
 945
 946 }
 947
 948 static GtkWidget* user_page (WizardWindow * wizard)
 949 {
 950         GtkWidget *table = gtk_table_new(1,1, FALSE);
 951         GtkWidget *vbox;
 952         GtkWidget *label;
 953         GtkWidget *user_table;
 954
 955         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
 956         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 957
 958         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
 959         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
 960
 961         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
 962                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 963
 964         user_table = gtk_table_new(3, 2, FALSE);
 965         gtk_table_set_row_spacings(GTK_TABLE(user_table), VSPACING_NARROW);
 966         gtk_box_pack_start(GTK_BOX(vbox), user_table, FALSE, FALSE, 0);
 967
 968         label = gtk_label_new(_("<span weight=\"bold\">Your name:</span>"));
 969         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 970         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 971         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,0,1,
 972                          GTK_FILL, 0, VSPACING_NARROW, 0);
 973         wizard->full_name = gtk_entry_new();
 974         gtk_entry_set_text(GTK_ENTRY(wizard->full_name), tmpl.name?tmpl.name:"");
 975         gtk_table_attach(GTK_TABLE(user_table), wizard->full_name, 1,2,0,1,
 976                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 977
 978         label = gtk_label_new(_("<span weight=\"bold\">Your email address:</span>"));
 979         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 980         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 981         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,1,2,
 982                          GTK_FILL, 0, VSPACING_NARROW, 0);
 983         wizard->email = gtk_entry_new();
 984         gtk_entry_set_text(GTK_ENTRY(wizard->email), tmpl.email?tmpl.email:"");
 985         gtk_table_attach(GTK_TABLE(user_table), wizard->email, 1,2,1,2,
 986                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 987
 988         label = gtk_label_new(_("Your organization:"));
 989         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 990         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,2,3,
 991                          GTK_FILL, 0, VSPACING_NARROW, 0);
 992         wizard->organization = gtk_entry_new();
 993         gtk_entry_set_text(GTK_ENTRY(wizard->organization), tmpl.organization?tmpl.organization:"");
 994         gtk_table_attach(GTK_TABLE(user_table), wizard->organization, 1,2,2,3,
 995                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 996
 997         g_signal_connect(G_OBJECT(wizard->email), "changed",
 998                          G_CALLBACK(wizard_email_changed),
 999                          wizard);
1000         return table;
1001 }
1002
1003 static GtkWidget* mailbox_page (WizardWindow * wizard)
1004 {
1005         GtkWidget *table = gtk_table_new(1,1, FALSE);
1006         GtkWidget *vbox;
1007         GtkWidget *hbox;
1008
1009         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1010         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1011
1012         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1013         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1014
1015         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1016                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1017
1018         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1019         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1020
1021         wizard->mailbox_label = gtk_label_new(_("<span weight=\"bold\">Mailbox name:</span>"));
1022         gtk_label_set_use_markup(GTK_LABEL(wizard->mailbox_label), TRUE);
1023         if (GTK_IS_MISC(wizard->mailbox_label))
1024                 gtk_misc_set_alignment(GTK_MISC(wizard->mailbox_label), 1, 0.5);
1025         wizard->mailbox_name = gtk_entry_new();
1026
1027         gtk_entry_set_text(GTK_ENTRY(wizard->mailbox_name), tmpl.mailbox?tmpl.mailbox:"");
1028
1029         CLAWS_SET_TIP(wizard->mailbox_name, _("You can also specify an absolute path, for example: "
1030                                "\"/home/john/Documents/Mail\""));
1031
1032         gtk_box_pack_start(GTK_BOX(hbox), wizard->mailbox_label, FALSE, FALSE, 0);
1033         gtk_box_pack_start(GTK_BOX(hbox), wizard->mailbox_name, TRUE, TRUE, 0);
1034
1035         return table;
1036 }
1037
1038 static void smtp_auth_changed (GtkWidget *btn, gpointer data)
1039 {
1040         WizardWindow *wizard = (WizardWindow *)data;
1041         gboolean do_auth = gtk_toggle_button_get_active(
1042                 GTK_TOGGLE_BUTTON(wizard->smtp_auth));
1043         gtk_widget_set_sensitive(wizard->smtp_username, do_auth);
1044         gtk_widget_set_sensitive(wizard->smtp_username_label, do_auth);
1045         gtk_widget_set_sensitive(wizard->smtp_password, do_auth);
1046         gtk_widget_set_sensitive(wizard->smtp_password_label, do_auth);
1047 }
1048
1049 #ifdef USE_GNUTLS
1050 static void cert_browse_cb(GtkWidget *widget, gpointer data)
1051 {
1052         GtkEntry *dest = GTK_ENTRY(data);
1053         gchar *filename;
1054         gchar *utf8_filename;
1055
1056         filename = filesel_select_file_open(_("Select certificate file"), NULL);
1057         if (!filename) return;
1058
1059         utf8_filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
1060         if (!utf8_filename) {
1061                 g_warning("cert_browse_cb(): failed to convert character set.");
1062                 utf8_filename = g_strdup(filename);
1063         }
1064         gtk_entry_set_text(dest, utf8_filename);
1065         g_free(utf8_filename);
1066 }
1067 #endif
1068
1069 static GtkWidget* smtp_page (WizardWindow * wizard)
1070 {
1071         GtkWidget *table = gtk_table_new(1, 1, FALSE);
1072         GtkWidget *vbox;
1073         GtkWidget *hbox;
1074         GtkWidget *hbox_spc;
1075         GtkWidget *smtp_auth_table;
1076         GtkWidget *label;
1077 #ifdef USE_GNUTLS
1078         GtkWidget *button;
1079         GtkWidget *smtp_cert_table;
1080 #endif
1081         gchar *text;
1082
1083         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1084         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1085
1086         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1087         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1088
1089         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1090                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1091
1092         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1093         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1094         wizard->smtp_server = gtk_entry_new();
1095         text = get_default_server(wizard, "smtp");
1096         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_server), text);
1097         g_free(text);
1098
1099         CLAWS_SET_TIP(wizard->smtp_server,
1100                              _("You can specify the port number by appending it at the end: "
1101                                "\"mail.example.com:25\""));
1102
1103         PACK_BOX(hbox, _("<span weight=\"bold\">SMTP server address:</span>"),
1104                  wizard->smtp_server);
1105
1106         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1107         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1108         wizard->smtp_auth = gtk_check_button_new_with_label(
1109                                         _("Use authentication"));
1110         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_auth),
1111                         tmpl.smtpauth);
1112         g_signal_connect(G_OBJECT(wizard->smtp_auth), "toggled",
1113                          G_CALLBACK(smtp_auth_changed),
1114                          wizard);
1115         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_auth, FALSE, FALSE, 0);
1116
1117         label = gtk_label_new(_("<span size=\"small\">(empty to use the same as receive)</span>"));
1118         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
1119         SET_TOGGLE_SENSITIVITY (wizard->smtp_auth, label);
1120         gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1121
1122         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1123         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1124         hbox_spc = gtk_hbox_new (FALSE, 0);
1125         gtk_widget_set_size_request (hbox_spc, 12, -1);
1126         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1127         smtp_auth_table = gtk_table_new(2, 2, FALSE);
1128         SET_TOGGLE_SENSITIVITY (wizard->smtp_auth, smtp_auth_table);
1129         gtk_box_pack_start(GTK_BOX(hbox), smtp_auth_table, TRUE, TRUE, 0);
1130
1131         wizard->smtp_username_label = gtk_label_new(_("SMTP username:"));
1132         gtk_misc_set_alignment(GTK_MISC(wizard->smtp_username_label), 1, 0.5);
1133         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_username_label, 0,1,0,1,
1134                          GTK_FILL, 0, VSPACING_NARROW, 0);
1135         text = get_default_smtp_account(wizard);
1136         wizard->smtp_username = gtk_entry_new();
1137         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_username), text);
1138         g_free(text);
1139         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_username, 1,2,0,1,
1140                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1141
1142         wizard->smtp_password_label = gtk_label_new(_("SMTP password:"));
1143         gtk_misc_set_alignment(GTK_MISC(wizard->smtp_password_label), 1, 0.5);
1144         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_password_label, 0,1,1,2,
1145                          GTK_FILL, 0, VSPACING_NARROW, 0);
1146         wizard->smtp_password = gtk_entry_new();
1147         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_password), tmpl.smtppass?tmpl.smtppass:"");
1148         gtk_entry_set_visibility(GTK_ENTRY(wizard->smtp_password), FALSE);
1149         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_password, 1,2,1,2,
1150                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1151 #ifdef USE_GNUTLS
1152         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1153         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1154         wizard->smtp_use_ssl = gtk_check_button_new_with_label(
1155                                         _("Use SSL to connect to SMTP server"));
1156         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl),
1157                         tmpl.smtpssl != 0);
1158         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_use_ssl, FALSE, FALSE, 0);
1159
1160         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1161         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1162         hbox_spc = gtk_hbox_new (FALSE, 0);
1163         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1164         gtk_widget_set_size_request (hbox_spc, 12, -1);
1165         wizard->smtp_use_tls = gtk_check_button_new_with_label(
1166                                         _("Use SSL via STARTTLS"));
1167         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_tls),
1168                         tmpl.smtpssl == 2);
1169         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_use_tls, FALSE, FALSE, 0);
1170         SET_TOGGLE_SENSITIVITY (wizard->smtp_use_ssl, wizard->smtp_use_tls);
1171
1172         smtp_cert_table = gtk_table_new(3,3, FALSE);
1173         gtk_box_pack_start (GTK_BOX(vbox), smtp_cert_table, FALSE, FALSE, 4);
1174         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1175         hbox_spc = gtk_hbox_new (FALSE, 0);
1176         gtk_widget_set_size_request (hbox_spc, 12, -1);
1177         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1178         label = gtk_label_new(_("Client SSL certificate (optional)"));
1179         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1180         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1181         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
1182         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1183         hbox_spc = gtk_hbox_new (FALSE, 0);
1184         gtk_widget_set_size_request (hbox_spc, 12, -1);
1185         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1186         label = gtk_label_new(_("File"));
1187         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1188         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1189         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 1, 1, 2,
1190                          GTK_FILL, 0, VSPACING_NARROW, 0);
1191         wizard->smtp_ssl_cert_file = gtk_entry_new();
1192         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_ssl_cert_file), tmpl.smtpssl_cert?tmpl.smtpssl_cert:"");
1193         gtk_table_attach(GTK_TABLE(smtp_cert_table), wizard->smtp_ssl_cert_file, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1194         button = gtkut_get_browse_file_btn(_("Browse"));
1195         gtk_table_attach(GTK_TABLE(smtp_cert_table), button, 2, 3, 1, 2,
1196                          GTK_FILL, 0, VSPACING_NARROW, 0);
1197         g_signal_connect(G_OBJECT(button), "clicked",
1198                          G_CALLBACK(cert_browse_cb), wizard->smtp_ssl_cert_file);
1199
1200         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1201         hbox_spc = gtk_hbox_new (FALSE, 0);
1202         gtk_widget_set_size_request (hbox_spc, 12, -1);
1203         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1204         label = gtk_label_new(_("Password"));
1205         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1206         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1207         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 1, 2, 3,
1208                          GTK_FILL, 0, VSPACING_NARROW, 0);
1209         wizard->smtp_ssl_cert_pass = gtk_entry_new();
1210         gtk_entry_set_visibility(GTK_ENTRY(wizard->smtp_ssl_cert_pass), FALSE);
1211         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_ssl_cert_pass), tmpl.smtpssl_cert_pass?tmpl.smtpssl_cert_pass:"");
1212         gtk_table_attach(GTK_TABLE(smtp_cert_table), wizard->smtp_ssl_cert_pass, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
1213         SET_TOGGLE_SENSITIVITY (wizard->smtp_use_ssl, smtp_cert_table);
1214         wizard->smtp_cert_table = smtp_cert_table;
1215 #endif
1216         smtp_auth_changed(NULL, wizard);
1217         return table;
1218 }
1219
1220 static void wizard_protocol_change(WizardWindow *wizard, RecvProtocol protocol)
1221 {
1222         gchar *text;
1223
1224         if (protocol == A_POP3) {
1225                 text = get_default_server(wizard, "pop");
1226                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1227                 gtk_widget_hide(wizard->recv_imap_label);
1228                 gtk_widget_hide(wizard->recv_imap_subdir);
1229                 gtk_widget_hide(wizard->subsonly_checkbtn);
1230                 gtk_widget_show(wizard->recv_username);
1231                 gtk_widget_show(wizard->recv_password);
1232                 gtk_widget_show(wizard->recv_username_label);
1233                 gtk_widget_show(wizard->recv_password_label);
1234                 gtk_widget_hide(wizard->no_imap_warning);
1235 #ifdef USE_GNUTLS
1236                 gtk_widget_show(wizard->recv_use_ssl);
1237                 gtk_widget_show(wizard->recv_use_tls);
1238                 gtk_widget_show(wizard->recv_cert_table);
1239 #endif
1240 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1241                 gtk_widget_show(wizard->auto_configure_btn);
1242                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1243                 gtk_widget_show(wizard->auto_configure_lbl);
1244 #endif
1245                 gtk_label_set_text(GTK_LABEL(wizard->recv_label), _("<span weight=\"bold\">Server address:</span>"));
1246                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1247                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1248                 g_free(text);
1249                 if (wizard->create_mailbox) {
1250                         gtk_widget_show(wizard->mailbox_label);
1251                         gtk_widget_show(wizard->mailbox_name);
1252                 }
1253         } else if (protocol == A_IMAP4) {
1254 #ifdef HAVE_LIBETPAN
1255                 text = get_default_server(wizard, "imap");
1256                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1257                 gtk_widget_show(wizard->recv_imap_label);
1258                 gtk_widget_show(wizard->recv_imap_subdir);
1259                 gtk_widget_show(wizard->subsonly_checkbtn);
1260                 gtk_widget_show(wizard->recv_username);
1261                 gtk_widget_show(wizard->recv_password);
1262                 gtk_widget_show(wizard->recv_username_label);
1263                 gtk_widget_show(wizard->recv_password_label);
1264                 gtk_widget_hide(wizard->no_imap_warning);
1265 #ifdef USE_GNUTLS
1266                 gtk_widget_show(wizard->recv_use_ssl);
1267                 gtk_widget_show(wizard->recv_use_tls);
1268                 gtk_widget_show(wizard->recv_cert_table);
1269 #endif
1270 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1271                 gtk_widget_show(wizard->auto_configure_btn);
1272                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1273                 gtk_widget_show(wizard->auto_configure_lbl);
1274 #endif
1275                 gtk_label_set_text(GTK_LABEL(wizard->recv_label), _("<span weight=\"bold\">Server address:</span>"));
1276                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1277                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1278                 g_free(text);
1279                 if (wizard->create_mailbox) {
1280                         gtk_widget_hide(wizard->mailbox_label);
1281                         gtk_widget_hide(wizard->mailbox_name);
1282                 }
1283 #else
1284                 gtk_widget_hide(wizard->recv_imap_label);
1285                 gtk_widget_hide(wizard->recv_imap_subdir);
1286                 gtk_widget_hide(wizard->subsonly_checkbtn);
1287                 gtk_widget_hide(wizard->recv_username);
1288                 gtk_widget_hide(wizard->recv_password);
1289                 gtk_widget_hide(wizard->recv_username_label);
1290                 gtk_widget_hide(wizard->recv_password_label);
1291                 gtk_widget_show(wizard->no_imap_warning);
1292                 if (wizard->create_mailbox) {
1293                         gtk_widget_hide(wizard->mailbox_label);
1294                         gtk_widget_hide(wizard->mailbox_name);
1295                 }
1296 #ifdef USE_GNUTLS
1297                 gtk_widget_hide(wizard->recv_use_ssl);
1298                 gtk_widget_hide(wizard->recv_use_tls);
1299                 gtk_widget_hide(wizard->recv_cert_table);
1300 #endif
1301                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, FALSE);
1302 #endif
1303         } else if (protocol == A_LOCAL) {
1304                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), tmpl.mboxfile?tmpl.mboxfile:"");
1305                 gtk_label_set_text(GTK_LABEL(wizard->recv_label), _("<span weight=\"bold\">Local mailbox:</span>"));
1306                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1307                 gtk_widget_hide(wizard->no_imap_warning);
1308                 gtk_widget_hide(wizard->recv_imap_label);
1309                 gtk_widget_hide(wizard->recv_imap_subdir);
1310                 gtk_widget_hide(wizard->subsonly_checkbtn);
1311                 gtk_widget_hide(wizard->recv_username);
1312                 gtk_widget_hide(wizard->recv_password);
1313                 gtk_widget_hide(wizard->recv_username_label);
1314                 gtk_widget_hide(wizard->recv_password_label);
1315 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1316                 gtk_widget_hide(wizard->auto_configure_btn);
1317                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1318                 gtk_widget_hide(wizard->auto_configure_lbl);
1319 #endif
1320 #ifdef USE_GNUTLS
1321                 gtk_widget_hide(wizard->recv_use_ssl);
1322                 gtk_widget_hide(wizard->recv_use_tls);
1323                 gtk_widget_hide(wizard->recv_cert_table);
1324 #endif
1325                 if (wizard->create_mailbox) {
1326                         gtk_widget_show(wizard->mailbox_label);
1327                         gtk_widget_show(wizard->mailbox_name);
1328                 }
1329                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1330         }
1331 }
1332
1333 static void wizard_protocol_changed(GtkComboBox *combo, gpointer data)
1334 {
1335         WizardWindow *wizard = (WizardWindow *)data;
1336         RecvProtocol protocol = combobox_get_active_data(combo);
1337
1338         wizard_protocol_change(wizard, protocol);
1339 }
1340
1341 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1342 static void auto_configure_cb (GtkWidget *widget, gpointer data)
1343 {
1344         gchar *address = NULL;
1345         AutoConfigureData *recv_data;
1346         AutoConfigureData *send_data;
1347         static GCancellable *recv_cancel = NULL;
1348         static GCancellable *send_cancel = NULL;
1349         WizardWindow *wizard = (WizardWindow *)data;
1350         RecvProtocol protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
1351
1352         if (!recv_cancel) {
1353                 recv_cancel = g_cancellable_new();
1354                 send_cancel = g_cancellable_new();
1355         }
1356
1357         if (widget == wizard->auto_configure_cancel_btn) {
1358                 g_cancellable_cancel(recv_cancel);
1359                 g_cancellable_cancel(send_cancel);
1360                 g_object_unref(recv_cancel);
1361                 g_object_unref(send_cancel);
1362                 recv_cancel = NULL;
1363                 send_cancel = NULL;
1364                 return;
1365         }
1366
1367         address = gtk_editable_get_chars(GTK_EDITABLE(wizard->email), 0, -1);
1368
1369         if (strchr(address, '@') == NULL) {
1370                 g_free(address);
1371                 gtk_label_set_text(GTK_LABEL(wizard->auto_configure_lbl),
1372                            _("Failed (wrong address)"));
1373                 return;
1374         }
1375
1376         if (protocol == A_POP3 || protocol == A_IMAP4) {
1377                 recv_data = g_new0(AutoConfigureData, 1);
1378                 recv_data->configure_button = GTK_BUTTON(wizard->auto_configure_btn);
1379                 recv_data->cancel_button = GTK_BUTTON(wizard->auto_configure_cancel_btn);
1380                 recv_data->info_label = GTK_LABEL(wizard->auto_configure_lbl);
1381                 recv_data->uid_entry = GTK_ENTRY(wizard->recv_username);
1382                 recv_data->cancel = recv_cancel;
1383                 switch(protocol) {
1384                 case A_POP3:
1385                         recv_data->ssl_service = "pop3s";
1386                         recv_data->tls_service = "pop3";
1387                         recv_data->address = g_strdup(address);
1388                         recv_data->hostname_entry = GTK_ENTRY(wizard->recv_server);
1389                         recv_data->set_port = NULL;
1390                         recv_data->port = NULL;
1391                         recv_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_tls);
1392                         recv_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_ssl);
1393                         recv_data->default_port = 110;
1394                         recv_data->default_ssl_port = 995;
1395                         break;
1396                 case A_IMAP4:
1397                         recv_data->ssl_service = "imaps";
1398                         recv_data->tls_service = "imap";
1399                         recv_data->address = g_strdup(address);
1400                         recv_data->hostname_entry = GTK_ENTRY(wizard->recv_server);
1401                         recv_data->set_port = NULL;
1402                         recv_data->port = NULL;
1403                         recv_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_tls);
1404                         recv_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_ssl);
1405                         recv_data->default_port = 143;
1406                         recv_data->default_ssl_port = 993;
1407                         break;
1408                 default:
1409                         cm_return_if_fail(FALSE);
1410                 }
1411                 auto_configure_service(recv_data);
1412         }
1413
1414         send_data = g_new0(AutoConfigureData, 1);
1415         send_data->configure_button = GTK_BUTTON(wizard->auto_configure_btn);
1416         send_data->cancel_button = GTK_BUTTON(wizard->auto_configure_cancel_btn);
1417         send_data->info_label = GTK_LABEL(wizard->auto_configure_lbl);
1418         send_data->cancel = send_cancel;
1419
1420         send_data->ssl_service = NULL;
1421         send_data->tls_service = "submission";
1422         send_data->address = g_strdup(address);
1423         send_data->hostname_entry = GTK_ENTRY(wizard->smtp_server);
1424         send_data->set_port = NULL;
1425         send_data->port = NULL;
1426         send_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_use_tls);
1427         send_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl);
1428         send_data->default_port = 25;
1429         send_data->default_ssl_port = -1;
1430         send_data->auth_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_auth);
1431
1432         auto_configure_service(send_data);
1433
1434         g_free(address);
1435 }
1436 #endif
1437
1438 static GtkWidget* recv_page (WizardWindow * wizard)
1439 {
1440         GtkWidget *table = gtk_table_new(1,1, FALSE);
1441         GtkWidget *vbox;
1442         GtkWidget *hbox;
1443         GtkWidget *hbox_spc;
1444         GtkWidget *recv_table;
1445         GtkWidget *label;
1446 #ifdef USE_GNUTLS
1447         GtkWidget *button;
1448         GtkWidget *recv_cert_table;
1449 #endif
1450 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1451         GtkWidget *auto_configure_btn;
1452         GtkWidget *auto_configure_cancel_btn;
1453         GtkWidget *auto_configure_lbl;
1454 #endif
1455         GtkListStore *store;
1456         GtkTreeIter iter;
1457         gchar *text;
1458         gint index = 0;
1459
1460         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1461         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1462
1463         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1464         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1465
1466         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1467                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1468
1469         recv_table = gtk_table_new(4, 2, FALSE);
1470
1471         gtk_box_pack_start(GTK_BOX(vbox), recv_table, FALSE, FALSE, 0);
1472
1473         label = gtk_label_new(_("<span weight=\"bold\">Server type:</span>"));
1474         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1475         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
1476         gtk_table_attach(GTK_TABLE(recv_table), label, 0,1,0,1,
1477                          GTK_FILL, 0, VSPACING_NARROW, 0);
1478         wizard->recv_type = gtkut_sc_combobox_create(NULL, FALSE);
1479         store = GTK_LIST_STORE(gtk_combo_box_get_model(
1480                         GTK_COMBO_BOX(wizard->recv_type)));
1481
1482         COMBOBOX_ADD(store, _("POP3"), A_POP3);
1483         COMBOBOX_ADD(store, _("IMAP"), A_IMAP4);
1484         COMBOBOX_ADD(store, _("Local mbox file"), A_LOCAL);
1485
1486         switch(tmpl.recvtype) {
1487         case A_POP3:
1488                 index = 0;
1489                 break;
1490         case A_IMAP4:
1491                 index = 1;
1492                 break;
1493         case A_LOCAL:
1494                 index = 2;
1495                 break;
1496         default:
1497                 index = 0;
1498         }
1499         gtk_combo_box_set_active(GTK_COMBO_BOX (wizard->recv_type), index);
1500         g_signal_connect(G_OBJECT(wizard->recv_type), "changed",
1501                          G_CALLBACK(wizard_protocol_changed),
1502                          wizard);
1503         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_type, 1,2,0,1,
1504                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1505
1506 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1507         auto_configure_btn = gtk_button_new_with_label(_("Auto-configure"));
1508         auto_configure_cancel_btn = gtk_button_new_with_label(_("Cancel"));
1509         gtk_table_attach(GTK_TABLE(recv_table), auto_configure_btn, 0,1,1,2,
1510                         GTK_FILL, 0, VSPACING_NARROW, 0);
1511         auto_configure_lbl = gtk_label_new("");
1512         gtk_misc_set_alignment(GTK_MISC(auto_configure_lbl), 0, 0.5);
1513         gtk_table_attach(GTK_TABLE(recv_table), auto_configure_lbl, 1,2,1,2,
1514                         GTK_FILL, 0, VSPACING_NARROW, 0);
1515         gtk_widget_show(auto_configure_btn);
1516         gtk_widget_show(auto_configure_lbl);
1517         wizard->auto_configure_lbl = auto_configure_lbl;
1518         wizard->auto_configure_btn = auto_configure_btn;
1519         wizard->auto_configure_cancel_btn = auto_configure_cancel_btn;
1520         g_signal_connect (G_OBJECT (auto_configure_btn), "clicked",
1521                           G_CALLBACK (auto_configure_cb), wizard);
1522         g_signal_connect (G_OBJECT (auto_configure_cancel_btn), "clicked",
1523                           G_CALLBACK (auto_configure_cb), wizard);
1524 #endif
1525
1526         wizard->recv_label = gtk_label_new(_("<span weight=\"bold\">Server address:</span>"));
1527         gtk_misc_set_alignment(GTK_MISC(wizard->recv_label), 1, 0.5);
1528         gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1529         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_label, 0,1,2,3,
1530                          GTK_FILL, 0, VSPACING_NARROW, 0);
1531         wizard->recv_server = gtk_entry_new();
1532         text = get_default_server(wizard, "pop");
1533         gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1534         g_free(text);
1535
1536         CLAWS_SET_TIP(wizard->recv_server,
1537                              _("You can specify the port number by appending it at the end: "
1538                                "\"mail.example.com:110\""));
1539         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_server, 1,2,2,3,
1540                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1541
1542         wizard->recv_username_label = gtk_label_new(_("<span weight=\"bold\">Username:</span>"));
1543         gtk_misc_set_alignment(GTK_MISC(wizard->recv_username_label), 1, 0.5);
1544         gtk_label_set_use_markup(GTK_LABEL(wizard->recv_username_label), TRUE);
1545         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_username_label, 0,1,3,4,
1546                          GTK_FILL, 0, VSPACING_NARROW, 0);
1547         wizard->recv_username = gtk_entry_new();
1548         text = get_default_account(wizard);
1549         gtk_entry_set_text(GTK_ENTRY(wizard->recv_username), text);
1550         g_free(text);
1551         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_username, 1,2,3,4,
1552                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1553
1554         wizard->recv_password_label = gtk_label_new(_("Password:"));
1555         gtk_misc_set_alignment(GTK_MISC(wizard->recv_password_label), 1, 0.5);
1556         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_password_label, 0,1,4,5,
1557                          GTK_FILL, 0, VSPACING_NARROW, 0);
1558         wizard->recv_password = gtk_entry_new();
1559         gtk_entry_set_text(GTK_ENTRY(wizard->recv_password), tmpl.recvpass?tmpl.recvpass:"");
1560         gtk_entry_set_visibility(GTK_ENTRY(wizard->recv_password), FALSE);
1561         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_password, 1,2,4,5,
1562                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1563 #ifdef USE_GNUTLS
1564         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1565         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1566         wizard->recv_use_ssl = gtk_check_button_new_with_label(
1567                                         _("Use SSL to connect to receiving server"));
1568         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->recv_use_ssl),
1569                         tmpl.recvssl != 0);
1570         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_use_ssl, FALSE, FALSE, 0);
1571
1572         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1573         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1574         hbox_spc = gtk_hbox_new (FALSE, 0);
1575         gtk_widget_set_size_request (hbox_spc, 12, -1);
1576         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1577         wizard->recv_use_tls = gtk_check_button_new_with_label(
1578                                         _("Use SSL via STARTTLS"));
1579         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->recv_use_tls),
1580                         tmpl.recvssl == 2);
1581         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_use_tls, FALSE, FALSE, 0);
1582         SET_TOGGLE_SENSITIVITY (wizard->recv_use_ssl, wizard->recv_use_tls);
1583
1584         recv_cert_table = gtk_table_new(3,3, FALSE);
1585         gtk_box_pack_start (GTK_BOX(vbox), recv_cert_table, FALSE, FALSE, 4);
1586         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1587         hbox_spc = gtk_hbox_new (FALSE, 0);
1588         gtk_widget_set_size_request (hbox_spc, 12, -1);
1589         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1590         label = gtk_label_new(_("Client SSL certificate (optional)"));
1591         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1592         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1593         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
1594         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1595         hbox_spc = gtk_hbox_new (FALSE, 0);
1596         gtk_widget_set_size_request (hbox_spc, 12, -1);
1597         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1598         label = gtk_label_new(_("File"));
1599         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1600         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1601         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 1, 1, 2,
1602                          GTK_FILL, 0, VSPACING_NARROW, 0);
1603         wizard->recv_ssl_cert_file = gtk_entry_new();
1604         gtk_entry_set_text(GTK_ENTRY(wizard->recv_ssl_cert_file), tmpl.recvssl_cert?tmpl.recvssl_cert:"");
1605         gtk_table_attach(GTK_TABLE(recv_cert_table), wizard->recv_ssl_cert_file, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1606         button = gtkut_get_browse_file_btn(_("Browse"));
1607         gtk_table_attach(GTK_TABLE(recv_cert_table), button, 2, 3, 1, 2,
1608                          GTK_FILL, 0, VSPACING_NARROW, 0);
1609         g_signal_connect(G_OBJECT(button), "clicked",
1610                          G_CALLBACK(cert_browse_cb), wizard->recv_ssl_cert_file);
1611
1612         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1613         hbox_spc = gtk_hbox_new (FALSE, 0);
1614         gtk_widget_set_size_request (hbox_spc, 12, -1);
1615         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1616         label = gtk_label_new(_("Password"));
1617         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1618         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1619         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 1, 2, 3,
1620                          GTK_FILL, 0, VSPACING_NARROW, 0);
1621         wizard->recv_ssl_cert_pass = gtk_entry_new();
1622         gtk_entry_set_visibility(GTK_ENTRY(wizard->recv_ssl_cert_pass), FALSE);
1623         gtk_entry_set_text(GTK_ENTRY(wizard->recv_ssl_cert_pass), tmpl.recvssl_cert_pass?tmpl.recvssl_cert_pass:"");
1624         gtk_table_attach(GTK_TABLE(recv_cert_table), wizard->recv_ssl_cert_pass, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
1625         SET_TOGGLE_SENSITIVITY (wizard->recv_use_ssl, recv_cert_table);
1626         wizard->recv_cert_table = recv_cert_table;
1627 #endif
1628         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1629         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1630         wizard->recv_imap_subdir = gtk_entry_new();
1631         gtk_entry_set_text(GTK_ENTRY(wizard->recv_imap_subdir), tmpl.imapdir?tmpl.imapdir:"");
1632         wizard->recv_imap_label = gtk_label_new(_("IMAP server directory:"));
1633         gtk_misc_set_alignment(GTK_MISC(wizard->recv_imap_label), 1, 0.5);
1634         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_imap_label, FALSE, FALSE, 0);
1635         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_imap_subdir, TRUE, TRUE, 0);
1636
1637         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1638         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1639         hbox_spc = gtk_hbox_new (FALSE, 0);
1640         gtk_widget_set_size_request (hbox_spc, 12, -1);
1641         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1642         wizard->subsonly_checkbtn = gtk_check_button_new_with_label(
1643                         _("Show only subscribed folders"));
1644         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->subsonly_checkbtn),
1645                         tmpl.subsonly);
1646         gtk_box_pack_start(GTK_BOX(hbox), wizard->subsonly_checkbtn, FALSE, FALSE, 0);
1647
1648         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1649         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1650         wizard->no_imap_warning = gtk_label_new(_(
1651                           "<span weight=\"bold\">Warning: this version of Claws Mail\n"
1652                           "has been built without IMAP support.</span>"));
1653         gtk_label_set_use_markup(GTK_LABEL(wizard->no_imap_warning), TRUE);
1654         gtk_box_pack_start(GTK_BOX(hbox), wizard->no_imap_warning, FALSE, FALSE, 0);
1655
1656         return table;
1657 }
1658
1659 static void
1660 wizard_response_cb (GtkDialog * dialog, int response, gpointer data)
1661 {
1662         WizardWindow * wizard = (WizardWindow *)data;
1663         int current_page, num_pages;
1664         gboolean skip_mailbox_page = FALSE;
1665         gint protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
1666
1667         if (protocol == A_IMAP4) {
1668                 skip_mailbox_page = TRUE;
1669         }
1670
1671         num_pages = g_slist_length(wizard->pages);
1672
1673         current_page = gtk_notebook_get_current_page (
1674                                 GTK_NOTEBOOK(wizard->notebook));
1675         if (response == CANCEL)
1676         {
1677                 wizard->result = FALSE;
1678                 wizard->finished = TRUE;
1679                 gtk_widget_destroy (GTK_WIDGET(dialog));
1680         }
1681         else if (response == FINISHED)
1682         {
1683                 if (!wizard_write_config(wizard)) {
1684                         current_page = gtk_notebook_get_current_page (
1685                                         GTK_NOTEBOOK(wizard->notebook));
1686                         goto set_sens;
1687                 }
1688                 wizard->result = TRUE;
1689                 wizard->finished = TRUE;
1690                 gtk_widget_destroy (GTK_WIDGET(dialog));
1691         }
1692         else
1693         {
1694                 if (response == GO_BACK)
1695                 {
1696                         if (current_page > 0) {
1697                                 current_page--;
1698                                 if (current_page == MAILBOX_PAGE && skip_mailbox_page) {
1699                                         /* mailbox */
1700                                         current_page--;
1701                                 }
1702                                 gtk_notebook_set_current_page (
1703                                         GTK_NOTEBOOK(wizard->notebook),
1704                                         current_page);
1705                         }
1706                 }
1707                 else if (response == GO_FORWARD)
1708                 {
1709                         if (current_page < (num_pages-1)) {
1710                                 current_page++;
1711                                 if (current_page == MAILBOX_PAGE && skip_mailbox_page) {
1712                                         /* mailbox */
1713                                         current_page++;
1714                                 }
1715                                 gtk_notebook_set_current_page (
1716                                         GTK_NOTEBOOK(wizard->notebook),
1717                                         current_page);
1718                         }
1719                 }
1720 set_sens:
1721                 gtk_dialog_set_response_sensitive (dialog, GO_BACK,
1722                                 current_page > 0);
1723                 gtk_dialog_set_response_sensitive (dialog, GO_FORWARD,
1724                                 current_page < (num_pages - 1));
1725                 if (current_page == (num_pages -1)) {
1726                         gtk_dialog_set_response_sensitive (dialog, FINISHED, TRUE);
1727                         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window), FINISHED);
1728                 } else {
1729                         gtk_dialog_set_response_sensitive (dialog, FINISHED, FALSE);
1730                         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window), GO_FORWARD);
1731                 }
1732
1733         }
1734 }
1735
1736 static gint wizard_close_cb(GtkWidget *widget, GdkEventAny *event,
1737                                  gpointer data)
1738 {
1739         WizardWindow *wizard = (WizardWindow *)data;
1740         wizard->result = FALSE;
1741         wizard->finished = TRUE;
1742
1743         return FALSE;
1744 }
1745
1746 #define PACK_WARNING(text) {                                            \
1747         label = gtk_label_new(text);                                    \
1748         gtk_misc_set_alignment(GTK_MISC(label), 0, 0);                  \
1749         gtk_box_pack_end(GTK_BOX(widget), label, FALSE, FALSE, 0);      \
1750 }
1751
1752 gboolean run_wizard(MainWindow *mainwin, gboolean create_mailbox) {
1753         WizardWindow *wizard = g_new0(WizardWindow, 1);
1754         GtkWidget *page;
1755         GtkWidget *widget;
1756         GtkWidget *label;
1757         GtkWidget *scrolled_window;
1758         gchar     *text;
1759         GSList    *cur;
1760         gboolean   result;
1761         gint i = 0;
1762         wizard->mainwin = mainwin;
1763         wizard->create_mailbox = create_mailbox;
1764
1765         gtk_widget_hide(mainwin->window);
1766
1767         wizard_read_defaults();
1768
1769         wizard->window = gtk_dialog_new_with_buttons (_("Claws Mail Setup Wizard"),
1770                         NULL, 0,
1771                         GTK_STOCK_GO_BACK, GO_BACK,
1772                         GTK_STOCK_GO_FORWARD, GO_FORWARD,
1773                         GTK_STOCK_SAVE, FINISHED,
1774                         GTK_STOCK_CANCEL, CANCEL,
1775                         NULL);
1776         gtk_widget_set_size_request(wizard->window, -1, 480);
1777         gtk_window_set_position(GTK_WINDOW(wizard->window), GTK_WIN_POS_CENTER);
1778
1779         g_signal_connect(wizard->window, "response",
1780                           G_CALLBACK(wizard_response_cb), wizard);
1781         gtk_widget_realize(wizard->window);
1782         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window),
1783                         GO_FORWARD);
1784         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1785                         GO_BACK, FALSE);
1786         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1787                         GO_FORWARD, TRUE);
1788         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1789                         FINISHED, FALSE);
1790         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1791                         CANCEL, TRUE);
1792
1793         wizard->notebook = gtk_notebook_new();
1794         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(wizard->notebook), FALSE);
1795         gtk_notebook_set_show_border(GTK_NOTEBOOK(wizard->notebook), FALSE);
1796         gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(wizard->window))),
1797                             wizard->notebook, TRUE, TRUE, 0);
1798
1799         wizard->pages = NULL;
1800
1801 /*welcome page: 0 */
1802         WELCOME_PAGE = i;
1803         page = create_page(wizard, _("Welcome to Claws Mail"));
1804
1805         wizard->pages = g_slist_append(wizard->pages, page);
1806         widget = stock_pixmap_widget(wizard->window,
1807                                 STOCK_PIXMAP_CLAWS_MAIL_LOGO);
1808
1809         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1810
1811         text = g_strdup(_("Welcome to the Claws Mail setup wizard.\n\n"
1812                           "We will begin by defining some basic "
1813                           "information about you and your most common "
1814                           "mail options so that you can start to use "
1815                           "Claws Mail in less than five minutes."));
1816         widget = gtk_label_new(text);
1817         gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
1818         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1819         g_free(text);
1820
1821 /* user page: 1 */
1822         i++;
1823         USER_PAGE = i;
1824         widget = create_page (wizard, _("About You"));
1825         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1826         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1827                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1828         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1829
1830         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1831                                               user_page(wizard));
1832         PACK_WARNING(_("Bold fields must be completed"));
1833
1834         wizard->pages = g_slist_append(wizard->pages, widget);
1835
1836 /* recv+auth page: 2 */
1837         i++;
1838         RECV_PAGE = i;
1839         widget = create_page (wizard, _("Receiving mail"));
1840         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1841         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1842                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1843         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1844
1845         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1846                                               recv_page(wizard));
1847         PACK_WARNING(_("Bold fields must be completed"));
1848
1849         wizard->pages = g_slist_append(wizard->pages, widget);
1850
1851 /*smtp page: 3 */
1852         i++;
1853         SMTP_PAGE = i;
1854         widget = create_page (wizard, _("Sending mail"));
1855         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1856         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1857                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1858         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1859
1860         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1861                                               smtp_page(wizard));
1862         PACK_WARNING(_("Bold fields must be completed"));
1863
1864         wizard->pages = g_slist_append(wizard->pages, widget);
1865
1866 /* mailbox page: 4 */
1867         if (create_mailbox) {
1868                 i++;
1869                 MAILBOX_PAGE = i;
1870                 widget = create_page (wizard, _("Saving mail on disk"));
1871                 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1872                 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1873                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1874                 gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1875
1876                 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1877                                               mailbox_page(wizard));
1878                 PACK_WARNING(_("Bold fields must be completed"));
1879
1880                 wizard->pages = g_slist_append(wizard->pages, widget);
1881         }
1882
1883 /* done page: 6 */
1884         i++;
1885         DONE_PAGE = i;
1886         page = create_page(wizard, _("Configuration finished"));
1887
1888         wizard->pages = g_slist_append(wizard->pages, page);
1889         widget = stock_pixmap_widget(wizard->window,
1890                                 STOCK_PIXMAP_CLAWS_MAIL_LOGO);
1891
1892         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1893
1894         text = g_strdup(_("Claws Mail is now ready.\n"
1895                           "Click Save to start."));
1896         widget = gtk_label_new(text);
1897         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1898         g_free(text);
1899
1900
1901         for (cur = wizard->pages; cur && cur->data; cur = cur->next) {
1902                 gtk_notebook_append_page (GTK_NOTEBOOK(wizard->notebook),
1903                                           GTK_WIDGET(cur->data), NULL);
1904         }
1905
1906         g_signal_connect(G_OBJECT(wizard->window), "delete_event",
1907                          G_CALLBACK(wizard_close_cb), wizard);
1908         gtk_widget_show_all (wizard->window);
1909
1910         gtk_widget_hide(wizard->recv_imap_label);
1911         gtk_widget_hide(wizard->recv_imap_subdir);
1912         gtk_widget_hide(wizard->subsonly_checkbtn);
1913 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1914         gtk_widget_hide(wizard->auto_configure_cancel_btn);
1915 #endif
1916         wizard_protocol_change(wizard, tmpl.recvtype);
1917
1918         while (!wizard->finished)
1919                 gtk_main_iteration();
1920
1921         result = wizard->result;
1922
1923         GTK_EVENTS_FLUSH();
1924
1925         gtk_widget_show(mainwin->window);
1926         g_free(wizard);
1927
1928         return result;
1929 }