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