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 "passwordstore.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->smtp_userid = g_strdup(
 761                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_username)));
 762
 763         passwd_store_set_account(prefs_account->account_id, PWS_ACCOUNT_RECV,
 764                         gtk_entry_get_text(GTK_ENTRY(wizard->recv_password)),
 765                         FALSE);
 766         passwd_store_set_account(prefs_account->account_id, PWS_ACCOUNT_SEND,
 767                         gtk_entry_get_text(GTK_ENTRY(wizard->smtp_password)),
 768                         FALSE);
 769
 770         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_auth))) {
 771                 prefs_account->use_smtp_auth = TRUE;
 772         }
 773
 774 #ifdef USE_GNUTLS
 775         smtp_ssl_type = SSL_NONE;
 776         recv_ssl_type = SSL_NONE;
 777
 778         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl))) {
 779                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_tls)))
 780                         smtp_ssl_type = SSL_STARTTLS;
 781                 else
 782                         smtp_ssl_type = SSL_TUNNEL;
 783         }
 784         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->recv_use_ssl))) {
 785                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(wizard->recv_use_tls)))
 786                         recv_ssl_type = SSL_STARTTLS;
 787                 else
 788                         recv_ssl_type = SSL_TUNNEL;
 789         }
 790
 791         prefs_account->ssl_smtp = smtp_ssl_type;
 792
 793         if (prefs_account->protocol == A_IMAP4)
 794                 prefs_account->ssl_imap = recv_ssl_type;
 795         else
 796                 prefs_account->ssl_pop = recv_ssl_type;
 797
 798         prefs_account->out_ssl_client_cert_file = g_strdup(
 799                                 gtk_entry_get_text(GTK_ENTRY(wizard->smtp_ssl_cert_file)));
 800         prefs_account->in_ssl_client_cert_file = g_strdup(
 801                                 gtk_entry_get_text(GTK_ENTRY(wizard->recv_ssl_cert_file)));
 802
 803         passwd_store_set_account(prefs_account->account_id, PWS_ACCOUNT_SEND_CERT,
 804                         gtk_entry_get_text(GTK_ENTRY(wizard->smtp_ssl_cert_pass)),
 805                         FALSE);
 806         passwd_store_set_account(prefs_account->account_id, PWS_ACCOUNT_RECV_CERT,
 807                         gtk_entry_get_text(GTK_ENTRY(wizard->recv_ssl_cert_pass)),
 808                         FALSE);
 809 #endif
 810
 811         if (prefs_account->protocol == A_IMAP4) {
 812                 gchar *directory = gtk_editable_get_chars(
 813                         GTK_EDITABLE(wizard->recv_imap_subdir), 0, -1);
 814                 if (directory && strlen(directory)) {
 815                         prefs_account->imap_dir = g_strdup(directory);
 816                 }
 817                 prefs_account->imap_subsonly =
 818                         gtk_toggle_button_get_active(
 819                                 GTK_TOGGLE_BUTTON(wizard->subsonly_checkbtn));
 820                 g_free(directory);
 821         }
 822
 823         account_list = g_list_append(account_list, prefs_account);
 824         prefs_account_write_config_all(account_list);
 825         prefs_account_free(prefs_account);
 826         account_read_config_all();
 827
 828         initialize_fonts(wizard);
 829         if (wizard->create_mailbox && prefs_account->protocol != A_IMAP4)
 830                 write_welcome_email(wizard);
 831
 832 #ifndef G_OS_WIN32
 833         plugin_load_standard_plugins();
 834 #endif
 835         return TRUE;
 836 }
 837
 838 static GtkWidget* create_page (WizardWindow *wizard, const char * title)
 839 {
 840         GtkWidget *w;
 841         GtkWidget *vbox;
 842         GtkWidget *hbox;
 843         GtkWidget *image;
 844         char *title_string;
 845
 846         vbox = gtk_vbox_new (FALSE, 6);
 847         gtk_container_set_border_width  (GTK_CONTAINER(vbox), 10);
 848
 849         /* create the titlebar */
 850         hbox = gtk_hbox_new (FALSE, 12);
 851         image = stock_pixmap_widget(wizard->window,
 852                                 STOCK_PIXMAP_CLAWS_MAIL_ICON);
 853         gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 0);
 854         title_string = g_strconcat ("<span size=\"xx-large\" weight=\"ultrabold\">", title ? title : "", "</span>", NULL);
 855         w = gtk_label_new (title_string);
 856         gtk_label_set_use_markup (GTK_LABEL(w), TRUE);
 857         g_free (title_string);
 858         gtk_box_pack_start (GTK_BOX(hbox), w, FALSE, FALSE, 0);
 859
 860         /* pack the titlebar */
 861         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 862
 863         /* pack the separator */
 864         gtk_box_pack_start (GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
 865
 866         /* pack space */
 867         w = gtk_alignment_new (0, 0, 0, 0);
 868         gtk_widget_set_size_request (w, 0, 6);
 869         gtk_box_pack_start (GTK_BOX(vbox), w, FALSE, FALSE, 0);
 870
 871         return vbox;
 872 }
 873
 874 #define PACK_BOX(hbox,text,entry) {                                     \
 875         GtkWidget *label = gtk_label_new(text);                         \
 876         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);               \
 877         if (GTK_IS_MISC(label))                                         \
 878                 gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);        \
 879         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);      \
 880         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);        \
 881 }
 882
 883 static gchar *get_default_server(WizardWindow * wizard, const gchar *type)
 884 {
 885         if (!strcmp(type, "smtp")) {
 886                 if (!tmpl.smtpserver || !strlen(tmpl.smtpserver))
 887                         return g_strconcat(type, ".", tmpl.domain, NULL);
 888                 else
 889                         return g_strdup(tmpl.smtpserver);
 890         } else {
 891                 if (!tmpl.recvserver || !strlen(tmpl.recvserver))
 892                         return g_strconcat(type, ".", tmpl.domain, NULL);
 893                 else
 894                         return g_strdup(tmpl.recvserver);
 895         }
 896 }
 897
 898 static gchar *get_default_account(WizardWindow * wizard)
 899 {
 900         gchar *result = NULL;
 901
 902         if (!tmpl.recvuser || !strlen(tmpl.recvuser)) {
 903                 result = gtk_editable_get_chars(
 904                                 GTK_EDITABLE(wizard->email), 0, -1);
 905
 906                 if (strstr(result, "@")) {
 907                         *(strstr(result,"@")) = '\0';
 908                 }
 909         } else {
 910                 result = g_strdup(tmpl.recvuser);
 911         }
 912         return result;
 913 }
 914
 915 static gchar *get_default_smtp_account(WizardWindow * wizard)
 916 {
 917         gchar *result = NULL;
 918
 919         if (!tmpl.smtpuser || !strlen(tmpl.smtpuser)) {
 920                 return g_strdup("");
 921         } else {
 922                 result = g_strdup(tmpl.smtpuser);
 923         }
 924         return result;
 925 }
 926
 927 static void wizard_email_changed(GtkWidget *widget, gpointer data)
 928 {
 929         WizardWindow *wizard = (WizardWindow *)data;
 930         RecvProtocol protocol;
 931         gchar *text;
 932         protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
 933
 934         text = get_default_server(wizard, "smtp");
 935         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_server), text);
 936         g_free(text);
 937
 938         text = get_default_account(wizard);
 939         gtk_entry_set_text(GTK_ENTRY(wizard->recv_username), text);
 940         g_free(text);
 941
 942         if (protocol == A_POP3) {
 943                 text = get_default_server(wizard, "pop");
 944                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
 945                 g_free(text);
 946         } else if (protocol == A_IMAP4) {
 947                 text = get_default_server(wizard, "imap");
 948                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
 949                 g_free(text);
 950         } else if (protocol == A_LOCAL) {
 951                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), tmpl.mboxfile?tmpl.mboxfile:"");
 952         }
 953
 954 }
 955
 956 static GtkWidget* user_page (WizardWindow * wizard)
 957 {
 958         GtkWidget *table = gtk_table_new(1,1, FALSE);
 959         GtkWidget *vbox;
 960         GtkWidget *label;
 961         GtkWidget *user_table;
 962
 963         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
 964         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 965
 966         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
 967         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
 968
 969         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
 970                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 971
 972         user_table = gtk_table_new(3, 2, FALSE);
 973         gtk_table_set_row_spacings(GTK_TABLE(user_table), VSPACING_NARROW);
 974         gtk_box_pack_start(GTK_BOX(vbox), user_table, FALSE, FALSE, 0);
 975
 976         label = gtk_label_new(g_strconcat("<span weight=\"bold\">", _("Your name:"),
 977                                           "</span>", NULL));
 978         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 979         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 980         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,0,1,
 981                          GTK_FILL, 0, VSPACING_NARROW, 0);
 982         wizard->full_name = gtk_entry_new();
 983         gtk_entry_set_text(GTK_ENTRY(wizard->full_name), tmpl.name?tmpl.name:"");
 984         gtk_table_attach(GTK_TABLE(user_table), wizard->full_name, 1,2,0,1,
 985                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 986
 987         label = gtk_label_new(g_strconcat("<span weight=\"bold\">", _("Your email address:"),
 988                                           "</span>", NULL));
 989         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 990         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
 991         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,1,2,
 992                          GTK_FILL, 0, VSPACING_NARROW, 0);
 993         wizard->email = gtk_entry_new();
 994         gtk_entry_set_text(GTK_ENTRY(wizard->email), tmpl.email?tmpl.email:"");
 995         gtk_table_attach(GTK_TABLE(user_table), wizard->email, 1,2,1,2,
 996                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
 997
 998         label = gtk_label_new(_("Your organization:"));
 999         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1000         gtk_table_attach(GTK_TABLE(user_table), label, 0,1,2,3,
1001                          GTK_FILL, 0, VSPACING_NARROW, 0);
1002         wizard->organization = gtk_entry_new();
1003         gtk_entry_set_text(GTK_ENTRY(wizard->organization), tmpl.organization?tmpl.organization:"");
1004         gtk_table_attach(GTK_TABLE(user_table), wizard->organization, 1,2,2,3,
1005                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1006
1007         g_signal_connect(G_OBJECT(wizard->email), "changed",
1008                          G_CALLBACK(wizard_email_changed),
1009                          wizard);
1010         return table;
1011 }
1012
1013 static GtkWidget* mailbox_page (WizardWindow * wizard)
1014 {
1015         GtkWidget *table = gtk_table_new(1,1, FALSE);
1016         GtkWidget *vbox;
1017         GtkWidget *hbox;
1018
1019         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1020         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1021
1022         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1023         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1024
1025         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1026                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1027
1028         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1029         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1030
1031         wizard->mailbox_label = gtk_label_new(g_strconcat("<span weight=\"bold\">",
1032                                                           _("Mailbox name:"), "</span>", NULL));
1033         gtk_label_set_use_markup(GTK_LABEL(wizard->mailbox_label), TRUE);
1034         if (GTK_IS_MISC(wizard->mailbox_label))
1035                 gtk_misc_set_alignment(GTK_MISC(wizard->mailbox_label), 1, 0.5);
1036         wizard->mailbox_name = gtk_entry_new();
1037
1038         gtk_entry_set_text(GTK_ENTRY(wizard->mailbox_name), tmpl.mailbox?tmpl.mailbox:"");
1039
1040         CLAWS_SET_TIP(wizard->mailbox_name, _("You can also specify an absolute path, for example: "
1041                                "\"/home/john/Documents/Mail\""));
1042
1043         gtk_box_pack_start(GTK_BOX(hbox), wizard->mailbox_label, FALSE, FALSE, 0);
1044         gtk_box_pack_start(GTK_BOX(hbox), wizard->mailbox_name, TRUE, TRUE, 0);
1045
1046         return table;
1047 }
1048
1049 static void smtp_auth_changed (GtkWidget *btn, gpointer data)
1050 {
1051         WizardWindow *wizard = (WizardWindow *)data;
1052         gboolean do_auth = gtk_toggle_button_get_active(
1053                 GTK_TOGGLE_BUTTON(wizard->smtp_auth));
1054         gtk_widget_set_sensitive(wizard->smtp_username, do_auth);
1055         gtk_widget_set_sensitive(wizard->smtp_username_label, do_auth);
1056         gtk_widget_set_sensitive(wizard->smtp_password, do_auth);
1057         gtk_widget_set_sensitive(wizard->smtp_password_label, do_auth);
1058 }
1059
1060 #ifdef USE_GNUTLS
1061 static void cert_browse_cb(GtkWidget *widget, gpointer data)
1062 {
1063         GtkEntry *dest = GTK_ENTRY(data);
1064         gchar *filename;
1065         gchar *utf8_filename;
1066
1067         filename = filesel_select_file_open(_("Select certificate file"), NULL);
1068         if (!filename) return;
1069
1070         utf8_filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
1071         if (!utf8_filename) {
1072                 g_warning("cert_browse_cb(): failed to convert character set.");
1073                 utf8_filename = g_strdup(filename);
1074         }
1075         gtk_entry_set_text(dest, utf8_filename);
1076         g_free(utf8_filename);
1077 }
1078 #endif
1079
1080 static GtkWidget* smtp_page (WizardWindow * wizard)
1081 {
1082         GtkWidget *table = gtk_table_new(1, 1, FALSE);
1083         GtkWidget *vbox;
1084         GtkWidget *hbox;
1085         GtkWidget *hbox_spc;
1086         GtkWidget *smtp_auth_table;
1087         GtkWidget *label;
1088 #ifdef USE_GNUTLS
1089         GtkWidget *button;
1090         GtkWidget *smtp_cert_table;
1091 #endif
1092         gchar *text;
1093
1094         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1095         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1096
1097         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1098         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1099
1100         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1101                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1102
1103         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1104         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1105         wizard->smtp_server = gtk_entry_new();
1106         text = get_default_server(wizard, "smtp");
1107         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_server), text);
1108         g_free(text);
1109
1110         CLAWS_SET_TIP(wizard->smtp_server,
1111                              _("You can specify the port number by appending it at the end: "
1112                                "\"mail.example.com:25\""));
1113
1114         PACK_BOX(hbox, g_strconcat("<span weight=\"bold\">", _("SMTP server address:"),
1115                                    "</span>", NULL), wizard->smtp_server);
1116
1117         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1118         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1119         wizard->smtp_auth = gtk_check_button_new_with_label(
1120                                         _("Use authentication"));
1121         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_auth),
1122                         tmpl.smtpauth);
1123         g_signal_connect(G_OBJECT(wizard->smtp_auth), "toggled",
1124                          G_CALLBACK(smtp_auth_changed),
1125                          wizard);
1126         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_auth, FALSE, FALSE, 0);
1127
1128         label = gtk_label_new(g_strconcat("<span size=\"small\">",
1129                                           _("(empty to use the same as receive)"), "</span>", NULL));
1130         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
1131         SET_TOGGLE_SENSITIVITY (wizard->smtp_auth, label);
1132         gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1133
1134         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1135         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1136         hbox_spc = gtk_hbox_new (FALSE, 0);
1137         gtk_widget_set_size_request (hbox_spc, 12, -1);
1138         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1139         smtp_auth_table = gtk_table_new(2, 2, FALSE);
1140         SET_TOGGLE_SENSITIVITY (wizard->smtp_auth, smtp_auth_table);
1141         gtk_box_pack_start(GTK_BOX(hbox), smtp_auth_table, TRUE, TRUE, 0);
1142
1143         wizard->smtp_username_label = gtk_label_new(_("SMTP username:"));
1144         gtk_misc_set_alignment(GTK_MISC(wizard->smtp_username_label), 1, 0.5);
1145         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_username_label, 0,1,0,1,
1146                          GTK_FILL, 0, VSPACING_NARROW, 0);
1147         text = get_default_smtp_account(wizard);
1148         wizard->smtp_username = gtk_entry_new();
1149         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_username), text);
1150         g_free(text);
1151         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_username, 1,2,0,1,
1152                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1153
1154         wizard->smtp_password_label = gtk_label_new(_("SMTP password:"));
1155         gtk_misc_set_alignment(GTK_MISC(wizard->smtp_password_label), 1, 0.5);
1156         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_password_label, 0,1,1,2,
1157                          GTK_FILL, 0, VSPACING_NARROW, 0);
1158         wizard->smtp_password = gtk_entry_new();
1159         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_password), tmpl.smtppass?tmpl.smtppass:"");
1160         gtk_entry_set_visibility(GTK_ENTRY(wizard->smtp_password), FALSE);
1161         gtk_table_attach(GTK_TABLE(smtp_auth_table), wizard->smtp_password, 1,2,1,2,
1162                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1163 #ifdef USE_GNUTLS
1164         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1165         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1166         wizard->smtp_use_ssl = gtk_check_button_new_with_label(
1167                                         _("Use SSL to connect to SMTP server"));
1168         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl),
1169                         tmpl.smtpssl != 0);
1170         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_use_ssl, FALSE, FALSE, 0);
1171
1172         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1173         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1174         hbox_spc = gtk_hbox_new (FALSE, 0);
1175         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1176         gtk_widget_set_size_request (hbox_spc, 12, -1);
1177         wizard->smtp_use_tls = gtk_check_button_new_with_label(
1178                                         _("Use SSL via STARTTLS"));
1179         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->smtp_use_tls),
1180                         tmpl.smtpssl == 2);
1181         gtk_box_pack_start(GTK_BOX(hbox), wizard->smtp_use_tls, FALSE, FALSE, 0);
1182         SET_TOGGLE_SENSITIVITY (wizard->smtp_use_ssl, wizard->smtp_use_tls);
1183
1184         smtp_cert_table = gtk_table_new(3,3, FALSE);
1185         gtk_box_pack_start (GTK_BOX(vbox), smtp_cert_table, FALSE, FALSE, 4);
1186         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1187         hbox_spc = gtk_hbox_new (FALSE, 0);
1188         gtk_widget_set_size_request (hbox_spc, 12, -1);
1189         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1190         label = gtk_label_new(_("Client SSL certificate (optional)"));
1191         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1192         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1193         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
1194         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1195         hbox_spc = gtk_hbox_new (FALSE, 0);
1196         gtk_widget_set_size_request (hbox_spc, 12, -1);
1197         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1198         label = gtk_label_new(_("File"));
1199         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1200         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1201         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 1, 1, 2,
1202                          GTK_FILL, 0, VSPACING_NARROW, 0);
1203         wizard->smtp_ssl_cert_file = gtk_entry_new();
1204         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_ssl_cert_file), tmpl.smtpssl_cert?tmpl.smtpssl_cert:"");
1205         gtk_table_attach(GTK_TABLE(smtp_cert_table), wizard->smtp_ssl_cert_file, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1206         button = gtkut_get_browse_file_btn(_("Browse"));
1207         gtk_table_attach(GTK_TABLE(smtp_cert_table), button, 2, 3, 1, 2,
1208                          GTK_FILL, 0, VSPACING_NARROW, 0);
1209         g_signal_connect(G_OBJECT(button), "clicked",
1210                          G_CALLBACK(cert_browse_cb), wizard->smtp_ssl_cert_file);
1211
1212         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1213         hbox_spc = gtk_hbox_new (FALSE, 0);
1214         gtk_widget_set_size_request (hbox_spc, 12, -1);
1215         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1216         label = gtk_label_new(_("Password"));
1217         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1218         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1219         gtk_table_attach(GTK_TABLE(smtp_cert_table), hbox, 0, 1, 2, 3,
1220                          GTK_FILL, 0, VSPACING_NARROW, 0);
1221         wizard->smtp_ssl_cert_pass = gtk_entry_new();
1222         gtk_entry_set_visibility(GTK_ENTRY(wizard->smtp_ssl_cert_pass), FALSE);
1223         gtk_entry_set_text(GTK_ENTRY(wizard->smtp_ssl_cert_pass), tmpl.smtpssl_cert_pass?tmpl.smtpssl_cert_pass:"");
1224         gtk_table_attach(GTK_TABLE(smtp_cert_table), wizard->smtp_ssl_cert_pass, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
1225         SET_TOGGLE_SENSITIVITY (wizard->smtp_use_ssl, smtp_cert_table);
1226         wizard->smtp_cert_table = smtp_cert_table;
1227 #endif
1228         smtp_auth_changed(NULL, wizard);
1229         return table;
1230 }
1231
1232 static void wizard_protocol_change(WizardWindow *wizard, RecvProtocol protocol)
1233 {
1234         gchar *text;
1235
1236         if (protocol == A_POP3) {
1237                 text = get_default_server(wizard, "pop");
1238                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1239                 gtk_widget_hide(wizard->recv_imap_label);
1240                 gtk_widget_hide(wizard->recv_imap_subdir);
1241                 gtk_widget_hide(wizard->subsonly_checkbtn);
1242                 gtk_widget_show(wizard->recv_username);
1243                 gtk_widget_show(wizard->recv_password);
1244                 gtk_widget_show(wizard->recv_username_label);
1245                 gtk_widget_show(wizard->recv_password_label);
1246                 gtk_widget_hide(wizard->no_imap_warning);
1247 #ifdef USE_GNUTLS
1248                 gtk_widget_show(wizard->recv_use_ssl);
1249                 gtk_widget_show(wizard->recv_use_tls);
1250                 gtk_widget_show(wizard->recv_cert_table);
1251 #endif
1252 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1253                 gtk_widget_show(wizard->auto_configure_btn);
1254                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1255                 gtk_widget_show(wizard->auto_configure_lbl);
1256 #endif
1257                 gtk_label_set_text(GTK_LABEL(wizard->recv_label),
1258                                    g_strconcat("<span weight=\"bold\">", _("Server address:"),
1259                                                 "</span>", NULL));
1260                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1261                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1262                 g_free(text);
1263                 if (wizard->create_mailbox) {
1264                         gtk_widget_show(wizard->mailbox_label);
1265                         gtk_widget_show(wizard->mailbox_name);
1266                 }
1267         } else if (protocol == A_IMAP4) {
1268 #ifdef HAVE_LIBETPAN
1269                 text = get_default_server(wizard, "imap");
1270                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1271                 gtk_widget_show(wizard->recv_imap_label);
1272                 gtk_widget_show(wizard->recv_imap_subdir);
1273                 gtk_widget_show(wizard->subsonly_checkbtn);
1274                 gtk_widget_show(wizard->recv_username);
1275                 gtk_widget_show(wizard->recv_password);
1276                 gtk_widget_show(wizard->recv_username_label);
1277                 gtk_widget_show(wizard->recv_password_label);
1278                 gtk_widget_hide(wizard->no_imap_warning);
1279 #ifdef USE_GNUTLS
1280                 gtk_widget_show(wizard->recv_use_ssl);
1281                 gtk_widget_show(wizard->recv_use_tls);
1282                 gtk_widget_show(wizard->recv_cert_table);
1283 #endif
1284 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1285                 gtk_widget_show(wizard->auto_configure_btn);
1286                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1287                 gtk_widget_show(wizard->auto_configure_lbl);
1288 #endif
1289                 gtk_label_set_text(GTK_LABEL(wizard->recv_label),
1290                                    g_strconcat("<span weight=\"bold\">", _("Server address:"),
1291                                                 "</span>", NULL));
1292                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1293                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1294                 g_free(text);
1295                 if (wizard->create_mailbox) {
1296                         gtk_widget_hide(wizard->mailbox_label);
1297                         gtk_widget_hide(wizard->mailbox_name);
1298                 }
1299 #else
1300                 gtk_widget_hide(wizard->recv_imap_label);
1301                 gtk_widget_hide(wizard->recv_imap_subdir);
1302                 gtk_widget_hide(wizard->subsonly_checkbtn);
1303                 gtk_widget_hide(wizard->recv_username);
1304                 gtk_widget_hide(wizard->recv_password);
1305                 gtk_widget_hide(wizard->recv_username_label);
1306                 gtk_widget_hide(wizard->recv_password_label);
1307                 gtk_widget_show(wizard->no_imap_warning);
1308                 if (wizard->create_mailbox) {
1309                         gtk_widget_hide(wizard->mailbox_label);
1310                         gtk_widget_hide(wizard->mailbox_name);
1311                 }
1312 #ifdef USE_GNUTLS
1313                 gtk_widget_hide(wizard->recv_use_ssl);
1314                 gtk_widget_hide(wizard->recv_use_tls);
1315                 gtk_widget_hide(wizard->recv_cert_table);
1316 #endif
1317                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, FALSE);
1318 #endif
1319         } else if (protocol == A_LOCAL) {
1320                 gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), tmpl.mboxfile?tmpl.mboxfile:"");
1321                 gtk_label_set_text(GTK_LABEL(wizard->recv_label),
1322                                    g_strconcat("<span weight=\"bold\">", _("Local mailbox:"),
1323                                                "</span>", NULL));
1324                 gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1325                 gtk_widget_hide(wizard->no_imap_warning);
1326                 gtk_widget_hide(wizard->recv_imap_label);
1327                 gtk_widget_hide(wizard->recv_imap_subdir);
1328                 gtk_widget_hide(wizard->subsonly_checkbtn);
1329                 gtk_widget_hide(wizard->recv_username);
1330                 gtk_widget_hide(wizard->recv_password);
1331                 gtk_widget_hide(wizard->recv_username_label);
1332                 gtk_widget_hide(wizard->recv_password_label);
1333 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1334                 gtk_widget_hide(wizard->auto_configure_btn);
1335                 gtk_widget_hide(wizard->auto_configure_cancel_btn);
1336                 gtk_widget_hide(wizard->auto_configure_lbl);
1337 #endif
1338 #ifdef USE_GNUTLS
1339                 gtk_widget_hide(wizard->recv_use_ssl);
1340                 gtk_widget_hide(wizard->recv_use_tls);
1341                 gtk_widget_hide(wizard->recv_cert_table);
1342 #endif
1343                 if (wizard->create_mailbox) {
1344                         gtk_widget_show(wizard->mailbox_label);
1345                         gtk_widget_show(wizard->mailbox_name);
1346                 }
1347                 gtk_dialog_set_response_sensitive (GTK_DIALOG(wizard->window), GO_FORWARD, TRUE);
1348         }
1349 }
1350
1351 static void wizard_protocol_changed(GtkComboBox *combo, gpointer data)
1352 {
1353         WizardWindow *wizard = (WizardWindow *)data;
1354         RecvProtocol protocol = combobox_get_active_data(combo);
1355
1356         wizard_protocol_change(wizard, protocol);
1357 }
1358
1359 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1360 static void auto_configure_cb (GtkWidget *widget, gpointer data)
1361 {
1362         gchar *address = NULL;
1363         AutoConfigureData *recv_data;
1364         AutoConfigureData *send_data;
1365         static GCancellable *recv_cancel = NULL;
1366         static GCancellable *send_cancel = NULL;
1367         WizardWindow *wizard = (WizardWindow *)data;
1368         RecvProtocol protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
1369
1370         if (!recv_cancel) {
1371                 recv_cancel = g_cancellable_new();
1372                 send_cancel = g_cancellable_new();
1373         }
1374
1375         if (widget == wizard->auto_configure_cancel_btn) {
1376                 g_cancellable_cancel(recv_cancel);
1377                 g_cancellable_cancel(send_cancel);
1378                 g_object_unref(recv_cancel);
1379                 g_object_unref(send_cancel);
1380                 recv_cancel = NULL;
1381                 send_cancel = NULL;
1382                 return;
1383         }
1384
1385         address = gtk_editable_get_chars(GTK_EDITABLE(wizard->email), 0, -1);
1386
1387         if (strchr(address, '@') == NULL) {
1388                 g_free(address);
1389                 gtk_label_set_text(GTK_LABEL(wizard->auto_configure_lbl),
1390                            _("Failed (wrong address)"));
1391                 return;
1392         }
1393
1394         if (protocol == A_POP3 || protocol == A_IMAP4) {
1395                 recv_data = g_new0(AutoConfigureData, 1);
1396                 recv_data->configure_button = GTK_BUTTON(wizard->auto_configure_btn);
1397                 recv_data->cancel_button = GTK_BUTTON(wizard->auto_configure_cancel_btn);
1398                 recv_data->info_label = GTK_LABEL(wizard->auto_configure_lbl);
1399                 recv_data->uid_entry = GTK_ENTRY(wizard->recv_username);
1400                 recv_data->cancel = recv_cancel;
1401                 switch(protocol) {
1402                 case A_POP3:
1403                         recv_data->ssl_service = "pop3s";
1404                         recv_data->tls_service = "pop3";
1405                         recv_data->address = g_strdup(address);
1406                         recv_data->hostname_entry = GTK_ENTRY(wizard->recv_server);
1407                         recv_data->set_port = NULL;
1408                         recv_data->port = NULL;
1409                         recv_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_tls);
1410                         recv_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_ssl);
1411                         recv_data->default_port = 110;
1412                         recv_data->default_ssl_port = 995;
1413                         break;
1414                 case A_IMAP4:
1415                         recv_data->ssl_service = "imaps";
1416                         recv_data->tls_service = "imap";
1417                         recv_data->address = g_strdup(address);
1418                         recv_data->hostname_entry = GTK_ENTRY(wizard->recv_server);
1419                         recv_data->set_port = NULL;
1420                         recv_data->port = NULL;
1421                         recv_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_tls);
1422                         recv_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->recv_use_ssl);
1423                         recv_data->default_port = 143;
1424                         recv_data->default_ssl_port = 993;
1425                         break;
1426                 default:
1427                         cm_return_if_fail(FALSE);
1428                 }
1429                 auto_configure_service(recv_data);
1430         }
1431
1432         send_data = g_new0(AutoConfigureData, 1);
1433         send_data->configure_button = GTK_BUTTON(wizard->auto_configure_btn);
1434         send_data->cancel_button = GTK_BUTTON(wizard->auto_configure_cancel_btn);
1435         send_data->info_label = GTK_LABEL(wizard->auto_configure_lbl);
1436         send_data->cancel = send_cancel;
1437
1438         send_data->ssl_service = NULL;
1439         send_data->tls_service = "submission";
1440         send_data->address = g_strdup(address);
1441         send_data->hostname_entry = GTK_ENTRY(wizard->smtp_server);
1442         send_data->set_port = NULL;
1443         send_data->port = NULL;
1444         send_data->tls_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_use_tls);
1445         send_data->ssl_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_use_ssl);
1446         send_data->default_port = 25;
1447         send_data->default_ssl_port = -1;
1448         send_data->auth_checkbtn = GTK_TOGGLE_BUTTON(wizard->smtp_auth);
1449
1450         auto_configure_service(send_data);
1451
1452         g_free(address);
1453 }
1454 #endif
1455
1456 static GtkWidget* recv_page (WizardWindow * wizard)
1457 {
1458         GtkWidget *table = gtk_table_new(1,1, FALSE);
1459         GtkWidget *vbox;
1460         GtkWidget *hbox;
1461         GtkWidget *hbox_spc;
1462         GtkWidget *recv_table;
1463         GtkWidget *label;
1464 #ifdef USE_GNUTLS
1465         GtkWidget *button;
1466         GtkWidget *recv_cert_table;
1467 #endif
1468 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1469         GtkWidget *auto_configure_btn;
1470         GtkWidget *auto_configure_cancel_btn;
1471         GtkWidget *auto_configure_lbl;
1472 #endif
1473         GtkListStore *store;
1474         GtkTreeIter iter;
1475         gchar *text;
1476         gint index = 0;
1477
1478         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
1479         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1480
1481         vbox = gtk_vbox_new(FALSE, VSPACING_NARROW);
1482         gtk_container_set_border_width(GTK_CONTAINER(vbox), VSPACING_NARROW_2);
1483
1484         gtk_table_attach(GTK_TABLE(table), vbox, 0,1,1,2,
1485                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1486
1487         recv_table = gtk_table_new(4, 2, FALSE);
1488
1489         gtk_box_pack_start(GTK_BOX(vbox), recv_table, FALSE, FALSE, 0);
1490
1491         label = gtk_label_new(g_strconcat("<span weight=\"bold\">", _("Server type:"), "</span>", NULL));
1492         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1493         gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
1494         gtk_table_attach(GTK_TABLE(recv_table), label, 0,1,0,1,
1495                          GTK_FILL, 0, VSPACING_NARROW, 0);
1496         wizard->recv_type = gtkut_sc_combobox_create(NULL, FALSE);
1497         store = GTK_LIST_STORE(gtk_combo_box_get_model(
1498                         GTK_COMBO_BOX(wizard->recv_type)));
1499
1500         COMBOBOX_ADD(store, _("POP3"), A_POP3);
1501         COMBOBOX_ADD(store, _("IMAP"), A_IMAP4);
1502         COMBOBOX_ADD(store, _("Local mbox file"), A_LOCAL);
1503
1504         switch(tmpl.recvtype) {
1505         case A_POP3:
1506                 index = 0;
1507                 break;
1508         case A_IMAP4:
1509                 index = 1;
1510                 break;
1511         case A_LOCAL:
1512                 index = 2;
1513                 break;
1514         default:
1515                 index = 0;
1516         }
1517         gtk_combo_box_set_active(GTK_COMBO_BOX (wizard->recv_type), index);
1518         g_signal_connect(G_OBJECT(wizard->recv_type), "changed",
1519                          G_CALLBACK(wizard_protocol_changed),
1520                          wizard);
1521         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_type, 1,2,0,1,
1522                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1523
1524 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1525         auto_configure_btn = gtk_button_new_with_label(_("Auto-configure"));
1526         auto_configure_cancel_btn = gtk_button_new_with_label(_("Cancel"));
1527         gtk_table_attach(GTK_TABLE(recv_table), auto_configure_btn, 0,1,1,2,
1528                         GTK_FILL, 0, VSPACING_NARROW, 0);
1529         auto_configure_lbl = gtk_label_new("");
1530         gtk_misc_set_alignment(GTK_MISC(auto_configure_lbl), 0, 0.5);
1531         gtk_table_attach(GTK_TABLE(recv_table), auto_configure_lbl, 1,2,1,2,
1532                         GTK_FILL, 0, VSPACING_NARROW, 0);
1533         gtk_widget_show(auto_configure_btn);
1534         gtk_widget_show(auto_configure_lbl);
1535         wizard->auto_configure_lbl = auto_configure_lbl;
1536         wizard->auto_configure_btn = auto_configure_btn;
1537         wizard->auto_configure_cancel_btn = auto_configure_cancel_btn;
1538         g_signal_connect (G_OBJECT (auto_configure_btn), "clicked",
1539                           G_CALLBACK (auto_configure_cb), wizard);
1540         g_signal_connect (G_OBJECT (auto_configure_cancel_btn), "clicked",
1541                           G_CALLBACK (auto_configure_cb), wizard);
1542 #endif
1543
1544         wizard->recv_label = gtk_label_new(g_strconcat("<span weight=\"bold\">",
1545                                                 _("Server address:"), "</span>", NULL));
1546         gtk_misc_set_alignment(GTK_MISC(wizard->recv_label), 1, 0.5);
1547         gtk_label_set_use_markup(GTK_LABEL(wizard->recv_label), TRUE);
1548         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_label, 0,1,2,3,
1549                          GTK_FILL, 0, VSPACING_NARROW, 0);
1550         wizard->recv_server = gtk_entry_new();
1551         text = get_default_server(wizard, "pop");
1552         gtk_entry_set_text(GTK_ENTRY(wizard->recv_server), text);
1553         g_free(text);
1554
1555         CLAWS_SET_TIP(wizard->recv_server,
1556                              _("You can specify the port number by appending it at the end: "
1557                                "\"mail.example.com:110\""));
1558         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_server, 1,2,2,3,
1559                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1560
1561         wizard->recv_username_label = gtk_label_new(g_strconcat("<span weight=\"bold\">",
1562                                                                 _("Username:"),"</span>", NULL));
1563         gtk_misc_set_alignment(GTK_MISC(wizard->recv_username_label), 1, 0.5);
1564         gtk_label_set_use_markup(GTK_LABEL(wizard->recv_username_label), TRUE);
1565         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_username_label, 0,1,3,4,
1566                          GTK_FILL, 0, VSPACING_NARROW, 0);
1567         wizard->recv_username = gtk_entry_new();
1568         text = get_default_account(wizard);
1569         gtk_entry_set_text(GTK_ENTRY(wizard->recv_username), text);
1570         g_free(text);
1571         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_username, 1,2,3,4,
1572                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1573
1574         wizard->recv_password_label = gtk_label_new(_("Password:"));
1575         gtk_misc_set_alignment(GTK_MISC(wizard->recv_password_label), 1, 0.5);
1576         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_password_label, 0,1,4,5,
1577                          GTK_FILL, 0, VSPACING_NARROW, 0);
1578         wizard->recv_password = gtk_entry_new();
1579         gtk_entry_set_text(GTK_ENTRY(wizard->recv_password), tmpl.recvpass?tmpl.recvpass:"");
1580         gtk_entry_set_visibility(GTK_ENTRY(wizard->recv_password), FALSE);
1581         gtk_table_attach(GTK_TABLE(recv_table), wizard->recv_password, 1,2,4,5,
1582                          GTK_EXPAND|GTK_FILL, 0, 0, 0);
1583 #ifdef USE_GNUTLS
1584         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1585         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1586         wizard->recv_use_ssl = gtk_check_button_new_with_label(
1587                                         _("Use SSL to connect to receiving server"));
1588         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->recv_use_ssl),
1589                         tmpl.recvssl != 0);
1590         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_use_ssl, FALSE, FALSE, 0);
1591
1592         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1593         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1594         hbox_spc = gtk_hbox_new (FALSE, 0);
1595         gtk_widget_set_size_request (hbox_spc, 12, -1);
1596         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1597         wizard->recv_use_tls = gtk_check_button_new_with_label(
1598                                         _("Use SSL via STARTTLS"));
1599         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->recv_use_tls),
1600                         tmpl.recvssl == 2);
1601         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_use_tls, FALSE, FALSE, 0);
1602         SET_TOGGLE_SENSITIVITY (wizard->recv_use_ssl, wizard->recv_use_tls);
1603
1604         recv_cert_table = gtk_table_new(3,3, FALSE);
1605         gtk_box_pack_start (GTK_BOX(vbox), recv_cert_table, FALSE, FALSE, 4);
1606         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1607         hbox_spc = gtk_hbox_new (FALSE, 0);
1608         gtk_widget_set_size_request (hbox_spc, 12, -1);
1609         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1610         label = gtk_label_new(_("Client SSL certificate (optional)"));
1611         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1612         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1613         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
1614         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1615         hbox_spc = gtk_hbox_new (FALSE, 0);
1616         gtk_widget_set_size_request (hbox_spc, 12, -1);
1617         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1618         label = gtk_label_new(_("File"));
1619         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1620         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1621         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 1, 1, 2,
1622                          GTK_FILL, 0, VSPACING_NARROW, 0);
1623         wizard->recv_ssl_cert_file = gtk_entry_new();
1624         gtk_entry_set_text(GTK_ENTRY(wizard->recv_ssl_cert_file), tmpl.recvssl_cert?tmpl.recvssl_cert:"");
1625         gtk_table_attach(GTK_TABLE(recv_cert_table), wizard->recv_ssl_cert_file, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1626         button = gtkut_get_browse_file_btn(_("Browse"));
1627         gtk_table_attach(GTK_TABLE(recv_cert_table), button, 2, 3, 1, 2,
1628                          GTK_FILL, 0, VSPACING_NARROW, 0);
1629         g_signal_connect(G_OBJECT(button), "clicked",
1630                          G_CALLBACK(cert_browse_cb), wizard->recv_ssl_cert_file);
1631
1632         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1633         hbox_spc = gtk_hbox_new (FALSE, 0);
1634         gtk_widget_set_size_request (hbox_spc, 12, -1);
1635         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1636         label = gtk_label_new(_("Password"));
1637         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
1638         gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1639         gtk_table_attach(GTK_TABLE(recv_cert_table), hbox, 0, 1, 2, 3,
1640                          GTK_FILL, 0, VSPACING_NARROW, 0);
1641         wizard->recv_ssl_cert_pass = gtk_entry_new();
1642         gtk_entry_set_visibility(GTK_ENTRY(wizard->recv_ssl_cert_pass), FALSE);
1643         gtk_entry_set_text(GTK_ENTRY(wizard->recv_ssl_cert_pass), tmpl.recvssl_cert_pass?tmpl.recvssl_cert_pass:"");
1644         gtk_table_attach(GTK_TABLE(recv_cert_table), wizard->recv_ssl_cert_pass, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
1645         SET_TOGGLE_SENSITIVITY (wizard->recv_use_ssl, recv_cert_table);
1646         wizard->recv_cert_table = recv_cert_table;
1647 #endif
1648         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1649         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1650         wizard->recv_imap_subdir = gtk_entry_new();
1651         gtk_entry_set_text(GTK_ENTRY(wizard->recv_imap_subdir), tmpl.imapdir?tmpl.imapdir:"");
1652         wizard->recv_imap_label = gtk_label_new(_("IMAP server directory:"));
1653         gtk_misc_set_alignment(GTK_MISC(wizard->recv_imap_label), 1, 0.5);
1654         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_imap_label, FALSE, FALSE, 0);
1655         gtk_box_pack_start(GTK_BOX(hbox), wizard->recv_imap_subdir, TRUE, TRUE, 0);
1656
1657         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1658         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1659         hbox_spc = gtk_hbox_new (FALSE, 0);
1660         gtk_widget_set_size_request (hbox_spc, 12, -1);
1661         gtk_box_pack_start (GTK_BOX (hbox), hbox_spc, FALSE, FALSE, 0);
1662         wizard->subsonly_checkbtn = gtk_check_button_new_with_label(
1663                         _("Show only subscribed folders"));
1664         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wizard->subsonly_checkbtn),
1665                         tmpl.subsonly);
1666         gtk_box_pack_start(GTK_BOX(hbox), wizard->subsonly_checkbtn, FALSE, FALSE, 0);
1667
1668         hbox = gtk_hbox_new(FALSE, VSPACING_NARROW);
1669         gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1670         wizard->no_imap_warning = gtk_label_new(g_strconcat("<span weight=\"bold\">",
1671                         _("Warning: this version of Claws Mail\n"
1672                           "has been built without IMAP support."), "</span>", NULL));
1673         gtk_label_set_use_markup(GTK_LABEL(wizard->no_imap_warning), TRUE);
1674         gtk_box_pack_start(GTK_BOX(hbox), wizard->no_imap_warning, FALSE, FALSE, 0);
1675
1676         return table;
1677 }
1678
1679 static void
1680 wizard_response_cb (GtkDialog * dialog, int response, gpointer data)
1681 {
1682         WizardWindow * wizard = (WizardWindow *)data;
1683         int current_page, num_pages;
1684         gboolean skip_mailbox_page = FALSE;
1685         gint protocol = combobox_get_active_data(GTK_COMBO_BOX(wizard->recv_type));
1686
1687         if (protocol == A_IMAP4) {
1688                 skip_mailbox_page = TRUE;
1689         }
1690
1691         num_pages = g_slist_length(wizard->pages);
1692
1693         current_page = gtk_notebook_get_current_page (
1694                                 GTK_NOTEBOOK(wizard->notebook));
1695         if (response == CANCEL)
1696         {
1697                 wizard->result = FALSE;
1698                 wizard->finished = TRUE;
1699                 gtk_widget_destroy (GTK_WIDGET(dialog));
1700         }
1701         else if (response == FINISHED)
1702         {
1703                 if (!wizard_write_config(wizard)) {
1704                         current_page = gtk_notebook_get_current_page (
1705                                         GTK_NOTEBOOK(wizard->notebook));
1706                         goto set_sens;
1707                 }
1708                 wizard->result = TRUE;
1709                 wizard->finished = TRUE;
1710                 gtk_widget_destroy (GTK_WIDGET(dialog));
1711         }
1712         else
1713         {
1714                 if (response == GO_BACK)
1715                 {
1716                         if (current_page > 0) {
1717                                 current_page--;
1718                                 if (current_page == MAILBOX_PAGE && skip_mailbox_page) {
1719                                         /* mailbox */
1720                                         current_page--;
1721                                 }
1722                                 gtk_notebook_set_current_page (
1723                                         GTK_NOTEBOOK(wizard->notebook),
1724                                         current_page);
1725                         }
1726                 }
1727                 else if (response == GO_FORWARD)
1728                 {
1729                         if (current_page < (num_pages-1)) {
1730                                 current_page++;
1731                                 if (current_page == MAILBOX_PAGE && skip_mailbox_page) {
1732                                         /* mailbox */
1733                                         current_page++;
1734                                 }
1735                                 gtk_notebook_set_current_page (
1736                                         GTK_NOTEBOOK(wizard->notebook),
1737                                         current_page);
1738                         }
1739                 }
1740 set_sens:
1741                 gtk_dialog_set_response_sensitive (dialog, GO_BACK,
1742                                 current_page > 0);
1743                 gtk_dialog_set_response_sensitive (dialog, GO_FORWARD,
1744                                 current_page < (num_pages - 1));
1745                 if (current_page == (num_pages -1)) {
1746                         gtk_dialog_set_response_sensitive (dialog, FINISHED, TRUE);
1747                         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window), FINISHED);
1748                 } else {
1749                         gtk_dialog_set_response_sensitive (dialog, FINISHED, FALSE);
1750                         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window), GO_FORWARD);
1751                 }
1752
1753         }
1754 }
1755
1756 static gint wizard_close_cb(GtkWidget *widget, GdkEventAny *event,
1757                                  gpointer data)
1758 {
1759         WizardWindow *wizard = (WizardWindow *)data;
1760         wizard->result = FALSE;
1761         wizard->finished = TRUE;
1762
1763         return FALSE;
1764 }
1765
1766 #define PACK_WARNING(text) {                                            \
1767         label = gtk_label_new(text);                                    \
1768         gtk_misc_set_alignment(GTK_MISC(label), 0, 0);                  \
1769         gtk_box_pack_end(GTK_BOX(widget), label, FALSE, FALSE, 0);      \
1770 }
1771
1772 gboolean run_wizard(MainWindow *mainwin, gboolean create_mailbox) {
1773         WizardWindow *wizard = g_new0(WizardWindow, 1);
1774         GtkWidget *page;
1775         GtkWidget *widget;
1776         GtkWidget *label;
1777         GtkWidget *scrolled_window;
1778         gchar     *text;
1779         GSList    *cur;
1780         gboolean   result;
1781         gint i = 0;
1782         wizard->mainwin = mainwin;
1783         wizard->create_mailbox = create_mailbox;
1784
1785         gtk_widget_hide(mainwin->window);
1786
1787         wizard_read_defaults();
1788
1789         wizard->window = gtk_dialog_new_with_buttons (_("Claws Mail Setup Wizard"),
1790                         NULL, 0,
1791                         GTK_STOCK_GO_BACK, GO_BACK,
1792                         GTK_STOCK_GO_FORWARD, GO_FORWARD,
1793                         GTK_STOCK_SAVE, FINISHED,
1794                         GTK_STOCK_CANCEL, CANCEL,
1795                         NULL);
1796         gtk_widget_set_size_request(wizard->window, -1, 480);
1797         gtk_window_set_position(GTK_WINDOW(wizard->window), GTK_WIN_POS_CENTER);
1798
1799         g_signal_connect(wizard->window, "response",
1800                           G_CALLBACK(wizard_response_cb), wizard);
1801         gtk_widget_realize(wizard->window);
1802         gtk_dialog_set_default_response(GTK_DIALOG(wizard->window),
1803                         GO_FORWARD);
1804         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1805                         GO_BACK, FALSE);
1806         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1807                         GO_FORWARD, TRUE);
1808         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1809                         FINISHED, FALSE);
1810         gtk_dialog_set_response_sensitive(GTK_DIALOG(wizard->window),
1811                         CANCEL, TRUE);
1812
1813         wizard->notebook = gtk_notebook_new();
1814         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(wizard->notebook), FALSE);
1815         gtk_notebook_set_show_border(GTK_NOTEBOOK(wizard->notebook), FALSE);
1816         gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(wizard->window))),
1817                             wizard->notebook, TRUE, TRUE, 0);
1818
1819         wizard->pages = NULL;
1820
1821 /*welcome page: 0 */
1822         WELCOME_PAGE = i;
1823         page = create_page(wizard, _("Welcome to Claws Mail"));
1824
1825         wizard->pages = g_slist_append(wizard->pages, page);
1826         widget = stock_pixmap_widget(wizard->window,
1827                                 STOCK_PIXMAP_CLAWS_MAIL_LOGO);
1828
1829         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1830
1831         text = g_strdup(_("Welcome to the Claws Mail setup wizard.\n\n"
1832                           "We will begin by defining some basic "
1833                           "information about you and your most common "
1834                           "mail options so that you can start to use "
1835                           "Claws Mail in less than five minutes."));
1836         widget = gtk_label_new(text);
1837         gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
1838         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1839         g_free(text);
1840
1841 /* user page: 1 */
1842         i++;
1843         USER_PAGE = i;
1844         widget = create_page (wizard, _("About You"));
1845         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1846         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1847                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1848         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1849
1850         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1851                                               user_page(wizard));
1852         PACK_WARNING(_("Bold fields must be completed"));
1853
1854         wizard->pages = g_slist_append(wizard->pages, widget);
1855
1856 /* recv+auth page: 2 */
1857         i++;
1858         RECV_PAGE = i;
1859         widget = create_page (wizard, _("Receiving mail"));
1860         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1861         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1862                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1863         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1864
1865         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1866                                               recv_page(wizard));
1867         PACK_WARNING(_("Bold fields must be completed"));
1868
1869         wizard->pages = g_slist_append(wizard->pages, widget);
1870
1871 /*smtp page: 3 */
1872         i++;
1873         SMTP_PAGE = i;
1874         widget = create_page (wizard, _("Sending mail"));
1875         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1876         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1877                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1878         gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1879
1880         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1881                                               smtp_page(wizard));
1882         PACK_WARNING(_("Bold fields must be completed"));
1883
1884         wizard->pages = g_slist_append(wizard->pages, widget);
1885
1886 /* mailbox page: 4 */
1887         if (create_mailbox) {
1888                 i++;
1889                 MAILBOX_PAGE = i;
1890                 widget = create_page (wizard, _("Saving mail on disk"));
1891                 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1892                 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1893                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1894                 gtk_box_pack_start(GTK_BOX(widget), scrolled_window, TRUE, TRUE, 0);
1895
1896                 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
1897                                               mailbox_page(wizard));
1898                 PACK_WARNING(_("Bold fields must be completed"));
1899
1900                 wizard->pages = g_slist_append(wizard->pages, widget);
1901         }
1902
1903 /* done page: 6 */
1904         i++;
1905         DONE_PAGE = i;
1906         page = create_page(wizard, _("Configuration finished"));
1907
1908         wizard->pages = g_slist_append(wizard->pages, page);
1909         widget = stock_pixmap_widget(wizard->window,
1910                                 STOCK_PIXMAP_CLAWS_MAIL_LOGO);
1911
1912         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1913
1914         text = g_strdup(_("Claws Mail is now ready.\n"
1915                           "Click Save to start."));
1916         widget = gtk_label_new(text);
1917         gtk_box_pack_start (GTK_BOX(page), widget, FALSE, FALSE, 0);
1918         g_free(text);
1919
1920
1921         for (cur = wizard->pages; cur && cur->data; cur = cur->next) {
1922                 gtk_notebook_append_page (GTK_NOTEBOOK(wizard->notebook),
1923                                           GTK_WIDGET(cur->data), NULL);
1924         }
1925
1926         g_signal_connect(G_OBJECT(wizard->window), "delete_event",
1927                          G_CALLBACK(wizard_close_cb), wizard);
1928         gtk_widget_show_all (wizard->window);
1929
1930         gtk_widget_hide(wizard->recv_imap_label);
1931         gtk_widget_hide(wizard->recv_imap_subdir);
1932         gtk_widget_hide(wizard->subsonly_checkbtn);
1933 #if (defined USE_GNUTLS && GLIB_CHECK_VERSION(2,22,0))
1934         gtk_widget_hide(wizard->auto_configure_cancel_btn);
1935 #endif
1936         wizard_protocol_change(wizard, tmpl.recvtype);
1937
1938         while (!wizard->finished)
1939                 gtk_main_iteration();
1940
1941         result = wizard->result;
1942
1943         GTK_EVENTS_FLUSH();
1944
1945         gtk_widget_show(mainwin->window);
1946         g_free(wizard);
1947
1948         return result;
1949 }