src/wizard.c

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