ompi fixes

6 files changed, 25 insertions, 13 deletions

diff --git a/kmicromail/libetpan/mime/mailmime_decode.c b/kmicromail/libetpan/mime/mailmime_decode.c
index e48ec19..dbaeb68 100644
--- a/kmicromail/libetpan/mime/mailmime_decode.c
+++ b/kmicromail/libetpan/mime/mailmime_decode.c
@@ -1,543 +1,544 @@
 /*
  * libEtPan! -- a mail stuff library
  *
  * Copyright (C) 2001, 2002 - DINH Viet Hoa
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the libEtPan! project nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 /*
  * $Id$
  */
 
 /*
   RFC 2047 : MIME (Multipurpose Internet Mail Extensions) Part Three:
              Message Header Extensions for Non-ASCII Text
 */
 
 #include "mailmime_decode.h"
 
 #include <ctype.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <string.h>
 #include <stdlib.h>
 
 #include "mailmime_content.h"
 
 #include "charconv.h"
 #include "mmapstring.h"
 #include "mailimf.h"
 
 #ifndef TRUE
 #define TRUE 1
 #endif
 
 #ifndef FALSE
 #define FALSE 0
 #endif
 
 static int mailmime_charset_parse(const char * message, size_t length,
                                   size_t * index, char ** charset);
 
 enum {
   MAILMIME_ENCODING_B,
   MAILMIME_ENCODING_Q
 };
 
 static int mailmime_encoding_parse(const char * message, size_t length,
                                    size_t * index, int * result);
 
 static int mailmime_etoken_parse(const char * message, size_t length,
                                  size_t * index, char ** result);
 
 static int
 mailmime_non_encoded_word_parse(const char * message, size_t length,
                                 size_t * index,
                                 char ** result);
 
 static int
 mailmime_encoded_word_parse(const char * message, size_t length,
                             size_t * index,
                             struct mailmime_encoded_word ** result);
      
 
 enum {
   TYPE_ERROR,
   TYPE_WORD,
   TYPE_ENCODED_WORD,
 };
 
 int mailmime_encoded_phrase_parse(const char * default_fromcode,
     const char * message, size_t length,
     size_t * index, const char * tocode,
     char ** result)
 {
   MMAPString * gphrase;
   struct mailmime_encoded_word * word;
   int first;
   size_t cur_token;
   int r;
   int res;
   char * str;
   char * wordutf8;
   int type;
 
   cur_token = * index;
 
   gphrase = mmap_string_new("");
   if (gphrase == NULL) {
     res = MAILIMF_ERROR_MEMORY;
     goto err;
   }
 
   first = TRUE;
 
   type = TYPE_ERROR; /* XXX - removes a gcc warning */
 
   while (1) {
 
     r = mailmime_encoded_word_parse(message, length, &cur_token, &word);
     if (r == MAILIMF_NO_ERROR) {
       if (!first) {
         if (type != TYPE_ENCODED_WORD) {
           if (mmap_string_append_c(gphrase, ' ') == NULL) {
             mailmime_encoded_word_free(word);
             res = MAILIMF_ERROR_MEMORY;
             goto free;
           }
         }
       }
       type = TYPE_ENCODED_WORD;
       wordutf8 = NULL;
       r = charconv(tocode, word->wd_charset, word->wd_text,
                    strlen(word->wd_text), &wordutf8);
       switch (r) {
       case MAIL_CHARCONV_ERROR_MEMORY:
         mailmime_encoded_word_free(word);
         res = MAILIMF_ERROR_MEMORY;
         goto free;
 
       case MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET:
       case MAIL_CHARCONV_ERROR_CONV:
         mailmime_encoded_word_free(word);
         res = MAILIMF_ERROR_PARSE;
         goto free;
       }
       
       if (wordutf8 != NULL) {
         if (mmap_string_append(gphrase, wordutf8) == NULL) {
           mailmime_encoded_word_free(word);
           free(wordutf8);
           res = MAILIMF_ERROR_MEMORY;
           goto free;
         }
         free(wordutf8);
       }
       mailmime_encoded_word_free(word);
       first = FALSE;
     }
     else if (r == MAILIMF_ERROR_PARSE) {
       /* do nothing */
     }
     else {
       res = r;
       goto free;
     }
 
     if (r == MAILIMF_ERROR_PARSE) {
       char * raw_word;
 
       r = mailmime_non_encoded_word_parse(message, length,
                                           &cur_token, &raw_word);
       if (r == MAILIMF_NO_ERROR) {
         if (!first) {
           if (mmap_string_append_c(gphrase, ' ') == NULL) {
             free(raw_word);
             res = MAILIMF_ERROR_MEMORY;
             goto free;
           }
         }
         type = TYPE_WORD;
         
         wordutf8 = NULL;
         r = charconv(tocode, default_fromcode, raw_word,
             strlen(raw_word), &wordutf8);
         
         switch (r) {
         case MAIL_CHARCONV_ERROR_MEMORY:
           free(raw_word);
           res = MAILIMF_ERROR_MEMORY;
           goto free;
           
         case MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET:
         case MAIL_CHARCONV_ERROR_CONV:
           free(raw_word);
           res = MAILIMF_ERROR_PARSE;
           goto free;
         }
         
         if (mmap_string_append(gphrase, wordutf8) == NULL) {
           free(wordutf8);
           free(raw_word);
           res = MAILIMF_ERROR_MEMORY;
           goto free;
         }
-        
+        // LUTZ fix
+        free(wordutf8);
         free(raw_word);
         first = FALSE;
       }
       else if (r == MAILIMF_ERROR_PARSE) {
         break;
       }
       else {
         res = r;
         goto free;
       }
     }
   }
 
   if (first) {
     res = MAILIMF_ERROR_PARSE;
     goto free;
   }
 
   str = strdup(gphrase->str);
   if (str == NULL) {
     res = MAILIMF_ERROR_MEMORY;
     goto free;
   }
   mmap_string_free(gphrase);
 
   * result = str;
   * index = cur_token;
 
   return MAILIMF_NO_ERROR;
 
  free:
   mmap_string_free(gphrase);
  err:
   return res;
 }
 
 static int
 mailmime_non_encoded_word_parse(const char * message, size_t length,
                                 size_t * index,
                                 char ** result)
 {
   int end;
   size_t cur_token;
   int res;
   char * text;
   int r;
   size_t begin;
 
   cur_token = * index;
 
   r = mailimf_fws_parse(message, length, &cur_token);
   if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
     res = r;
     goto err;
   }
 
   begin = cur_token;
 
   end = FALSE;
   while (1) {
     if (cur_token >= length)
       break;
 
     switch (message[cur_token]) {
       case ' ':
       case '\t':
       case '\r':
       case '\n':
         end = TRUE;
         break;
     }
 
     if (end)
       break;
 
     cur_token ++;
   }
 
   if (cur_token - begin == 0) {
     res = MAILIMF_ERROR_PARSE;
     goto err;
   }
 
   text = malloc(cur_token - begin + 1);
   if (text == NULL) {
     res = MAILIMF_ERROR_MEMORY;
     goto err;
   }
 
   memcpy(text, message + begin, cur_token - begin);
   text[cur_token - begin] = '\0';
 
   * index = cur_token;
   * result = text;
 
   return MAILIMF_NO_ERROR;
 
  err:
   return res;
 }
 
 static int mailmime_encoded_word_parse(const char * message, size_t length,
                                        size_t * index,
                                        struct mailmime_encoded_word ** result)
 {
   size_t cur_token;
   char * charset;
   int encoding;
   char * text;
   size_t end_encoding;
   char * decoded;
   size_t decoded_len;
   struct mailmime_encoded_word * ew;
   int r;
   int res;
   int opening_quote;
   int end;
 
   cur_token = * index;
 
   r = mailimf_fws_parse(message, length, &cur_token);
   if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
     res = r;
     goto err;
   }
 
   opening_quote = FALSE;
   r = mailimf_char_parse(message, length, &cur_token, '\"');
   if (r == MAILIMF_NO_ERROR) {
     opening_quote = TRUE;
   }
   else if (r == MAILIMF_ERROR_PARSE) {
     /* do nothing */  
   }
   else {
     res = r;
     goto err;
   }
 
   r = mailimf_token_case_insensitive_parse(message, length, &cur_token, "=?");
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto err;
   }
 
   r = mailmime_charset_parse(message, length, &cur_token, &charset);
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto err;
   }
 
   r = mailimf_char_parse(message, length, &cur_token, '?');
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto free_charset;
   }
 
   r = mailmime_encoding_parse(message, length, &cur_token, &encoding);
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto free_charset;
   }
 
   r = mailimf_char_parse(message, length, &cur_token, '?');
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto free_charset;
   }
 
   end = FALSE;
   end_encoding = cur_token;
   while (1) {
     if (end_encoding >= length)
       break;
 
     switch (message[end_encoding]) {
       case '?':
 #if 0
       case ' ':
 #endif
         end = TRUE;
         break;
     }
 
     if (end)
       break;
 
     end_encoding ++;
   }
 
   decoded_len = 0;
   decoded = NULL;
   switch (encoding) {
   case MAILMIME_ENCODING_B:
     r = mailmime_base64_body_parse(message, end_encoding,
                                    &cur_token, &decoded,
                                    &decoded_len);
       
     if (r != MAILIMF_NO_ERROR) {
       res = r;
       goto free_charset;
     }
     break;
   case MAILMIME_ENCODING_Q:
     r = mailmime_quoted_printable_body_parse(message, end_encoding,
                                              &cur_token, &decoded,
                                              &decoded_len, TRUE);
 
     if (r != MAILIMF_NO_ERROR) {
       res = r;
       goto free_charset;
     }
 
     break;
   }
 
   text = malloc(decoded_len + 1);
   if (text == NULL) {
     res = MAILIMF_ERROR_MEMORY;
     goto free_charset;
   }
 
   if (decoded_len > 0)
     memcpy(text, decoded, decoded_len);
   text[decoded_len] = '\0';
 
   mailmime_decoded_part_free(decoded);
 
   r = mailimf_token_case_insensitive_parse(message, length, &cur_token, "?=");
   if (r != MAILIMF_NO_ERROR) {
     res = r;
     goto free_encoded_text;
   }
 
   if (opening_quote) {
     r = mailimf_char_parse(message, length, &cur_token, '\"');
     if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
       res = r;
       goto free_encoded_text;
     }
   }
 
   ew = mailmime_encoded_word_new(charset, text);
   if (ew == NULL) {
     res = MAILIMF_ERROR_MEMORY;
     goto free_encoded_text;
   }
 
   * result = ew;
   * index = cur_token;
   
   return MAILIMF_NO_ERROR;
 
  free_encoded_text:
   mailmime_encoded_text_free(text);
  free_charset:
   mailmime_charset_free(charset);
  err:
   return res;
 }
 
 static int mailmime_charset_parse(const char * message, size_t length,
                                   size_t * index, char ** charset)
 {
   return mailmime_etoken_parse(message, length, index, charset);
 }
 
 static int mailmime_encoding_parse(const char * message, size_t length,
                                    size_t * index, int * result)
 {
   size_t cur_token;
   int encoding;
 
   cur_token = * index;
 
   if (cur_token >= length)
     return MAILIMF_ERROR_PARSE;
 
   switch ((char) toupper((unsigned char) message[cur_token])) {
   case 'Q':
     encoding = MAILMIME_ENCODING_Q;
     break;
   case 'B':
     encoding = MAILMIME_ENCODING_B;
     break;
   default:
     return MAILIMF_ERROR_INVAL;
   }
 
   cur_token ++;
 
   * result = encoding;
   * index = cur_token;
 
   return MAILIMF_NO_ERROR;
 }
 
 int is_etoken_char(char ch)
 {
   unsigned char uch = ch;
 
   if (uch < 31)
     return FALSE;
 
   switch (uch) {
   case ' ':
   case '(':
   case ')':
   case '<':
   case '>':
   case '@':
   case ',':
   case ';':
   case ':':
   case '"':
   case '/':
   case '[':
   case ']':
   case '?':
   case '.':
   case '=':
     return FALSE;
   }
 
   return TRUE;
 }
 
 static int mailmime_etoken_parse(const char * message, size_t length,
                                  size_t * index, char ** result)
 {
   return mailimf_custom_string_parse(message, length,
                                      index, result,
                                      is_etoken_char);
 }
diff --git a/kmicromail/libmailwrapper/generatemail.cpp b/kmicromail/libmailwrapper/generatemail.cpp
index 49315ba..32311d7 100644
--- a/kmicromail/libmailwrapper/generatemail.cpp
+++ b/kmicromail/libmailwrapper/generatemail.cpp
@@ -1,460 +1,461 @@
 #include "generatemail.h"
 #include "mailwrapper.h"
 
 #include <libetpan/libetpan.h>
 
 //#include <qt.h>
 
 #include <stdlib.h>
 #include <qfileinfo.h>
 
 using namespace Opie::Core;
-const char* Generatemail::USER_AGENT="OpieMail v0.6";
+const char* Generatemail::USER_AGENT="KOpieMail 33 1/3";
 
 Generatemail::Generatemail()
 {
 }
 
 Generatemail::~Generatemail()
 {
 }
 
 void Generatemail::addRcpts( clist *list, mailimf_address_list *addr_list ) {
     clistiter *it, *it2;
 
     for ( it = clist_begin( addr_list->ad_list ); it; it = it->next ) {
         mailimf_address *addr;
         addr = (mailimf_address *) it->data;
 
         if ( addr->ad_type == MAILIMF_ADDRESS_MAILBOX ) {
             esmtp_address_list_add( list, addr->ad_data.ad_mailbox->mb_addr_spec, 0, NULL );
         } else if ( addr->ad_type == MAILIMF_ADDRESS_GROUP ) {
             clist *l = addr->ad_data.ad_group->grp_mb_list->mb_list;
             for ( it2 = clist_begin( l ); it2; it2 = it2->next ) {
                 mailimf_mailbox *mbox;
                 mbox = (mailimf_mailbox *) it2->data;
                 esmtp_address_list_add( list, mbox->mb_addr_spec, 0, NULL );
             }
         }
     }
 }
 
 char *Generatemail::getFrom( mailimf_field *ffrom) {
     char *from = NULL;
     if ( ffrom && (ffrom->fld_type == MAILIMF_FIELD_FROM)
             && ffrom->fld_data.fld_from->frm_mb_list && ffrom->fld_data.fld_from->frm_mb_list->mb_list ) {
         clist *cl = ffrom->fld_data.fld_from->frm_mb_list->mb_list;
         clistiter *it;
         for ( it = clist_begin( cl ); it; it = it->next ) {
             mailimf_mailbox *mb = (mailimf_mailbox *) it->data;
             from = strdup( mb->mb_addr_spec );
         }
     }
 
     return from;
 }
 
 char *Generatemail::getFrom( mailmime *mail ) {
     /* no need to delete - its just a pointer to structure content */
     mailimf_field *ffrom = 0;
     ffrom = getField( mail->mm_data.mm_message.mm_fields, MAILIMF_FIELD_FROM );
     return getFrom(ffrom);
 }
 
 mailimf_field *Generatemail::getField( mailimf_fields *fields, int type ) {
     mailimf_field *field;
     clistiter *it;
 
     it = clist_begin( fields->fld_list );
     while ( it ) {
         field = (mailimf_field *) it->data;
         if ( field->fld_type == type ) {
             return field;
         }
         it = it->next;
     }
 
     return NULL;
 }
 
 mailimf_address_list *Generatemail::parseAddresses(const QString&addr ) {
     mailimf_address_list *addresses;
 
     if ( addr.isEmpty() )
         return NULL;
 
     addresses = mailimf_address_list_new_empty();
 
     bool literal_open = false;
     unsigned int startpos = 0;
     QStringList list;
     QString s;
     unsigned int i = 0;
     for (; i < addr.length();++i) {
         switch (addr[i]) {
         case '\"':
             literal_open = !literal_open;
             break;
         case ',':
             if (!literal_open) {
                 s = addr.mid(startpos,i-startpos);
                 if (!s.isEmpty()) {
                     list.append(s);
                 }
                 // !!!! this is a MUST BE!
                 startpos = ++i;
             }
             break;
         default:
             break;
         }
     }
     s = addr.mid(startpos,i-startpos);
     if (!s.isEmpty()) {
         list.append(s);
     }
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); it++ ) {
         int err = mailimf_address_list_add_parse( addresses, (char*)(*it).latin1() );
         if ( err != MAILIMF_NO_ERROR ) {
             qDebug(" Error parsing"); // *it
         } else {
         }
     }
     return addresses;
 }
 
 mailmime *Generatemail::buildFilePart(const QString&filename,const QString&mimetype,const QString&TextContent ) {
     mailmime * filePart = 0;
     mailmime_fields * fields = 0;
     mailmime_content * content = 0;
     mailmime_parameter * param = 0;
     char*name = 0;
     char*file = 0;
     int err;
-
     int pos = filename.findRev( '/' );
 
     if (filename.length()>0) {
         QString tmp = filename.right( filename.length() - ( pos + 1 ) );
         name = strdup( tmp.latin1() );        // just filename
         file = strdup( filename.latin1() );   // full name with path
     }
 
     int disptype = MAILMIME_DISPOSITION_TYPE_ATTACHMENT;
     int mechanism = MAILMIME_MECHANISM_BASE64;
 
     if ( mimetype.startsWith( "text/" ) ) {
         param = mailmime_parameter_new( strdup( "charset" ),
                                         strdup( "iso-8859-1" ) );
         mechanism = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
     }
 
     fields = mailmime_fields_new_filename(
                  disptype, name,
                  mechanism );
     content = mailmime_content_new_with_str( (char*)mimetype.latin1() );
     if (content!=0 && fields != 0) {
         if (param) {
             clist_append(content->ct_parameters,param);
             param = 0;
         }
         if (filename.length()>0) {
             QFileInfo f(filename);
             param = mailmime_parameter_new(strdup("name"),strdup(f.fileName().latin1()));
             clist_append(content->ct_parameters,param);
             param = 0;
         }
         filePart = mailmime_new_empty( content, fields );
     }
     if (filePart) {
         if (filename.length()>0) {
             err = mailmime_set_body_file( filePart, file );
         } else {
-            err = mailmime_set_body_text(filePart,strdup(TextContent.data()),TextContent.length());
+            err = mailmime_set_body_text(filePart,strdup( TextContent.utf8()),TextContent.utf8().length());
         }
         if (err != MAILIMF_NO_ERROR) {
             qDebug("Error setting body with file "); 
             mailmime_free( filePart );
             filePart = 0;
         }
     }
 
     if (!filePart) {
         if ( param != NULL ) {
             mailmime_parameter_free( param );
         }
         if (content) {
             mailmime_content_free( content );
         }
         if (fields) {
             mailmime_fields_free( fields );
         } else {
             if (name) {
                 free( name );
             }
             if (file) {
                 free( file );
             }
         }
     }
     return filePart;        // Success :)
 
 }
 
 void Generatemail::addFileParts( mailmime *message,const QList<Attachment>&files ) {
     const Attachment *it;
     unsigned int count = files.count();
     for ( unsigned int i = 0; i < count; ++i ) {
         mailmime *filePart;
         int err;
         it = ((QList<Attachment>)files).at(i);
 
         filePart = buildFilePart( it->getFileName(), it->getMimeType(),"" );
         if ( filePart == NULL ) {
             continue;
         }
         err = mailmime_smart_add_part( message, filePart );
         if ( err != MAILIMF_NO_ERROR ) {
             mailmime_free( filePart );
         }
     }
 }
 
 mailmime *Generatemail::buildTxtPart(const QString&str ) {
     mailmime *txtPart;
     mailmime_fields *fields;
     mailmime_content *content;
     mailmime_parameter *param;
     int err;
-
+    QCString __str;
     param = mailmime_parameter_new( strdup( "charset" ),
                                     strdup( "iso-8859-1" ) );
     if ( param == NULL )
         goto err_free;
 
     content = mailmime_content_new_with_str( "text/plain" );
     if ( content == NULL )
         goto err_free_param;
 
     err = clist_append( content->ct_parameters, param );
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_content;
 
     fields = mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT);
     if ( fields == NULL )
         goto err_free_content;
 
     txtPart = mailmime_new_empty( content, fields );
     if ( txtPart == NULL )
         goto err_free_fields;
-
-    err = mailmime_set_body_text( txtPart, (char*)str.data(), str.length() );
+    {
+        __str = str.utf8();
+        err = mailmime_set_body_text( txtPart, __str.data(), __str.length() );
+    }
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_txtPart;
 
     return txtPart;     // Success :)
 
 err_free_txtPart:
     mailmime_free( txtPart );
 err_free_fields:
     mailmime_fields_free( fields );
 err_free_content:
     mailmime_content_free( content );
 err_free_param:
     mailmime_parameter_free( param );
 err_free:
     ;
 
     return NULL;        // Error :(
 }
 
 mailimf_mailbox *Generatemail::newMailbox(const QString&name, const QString&mail ) {
     return mailimf_mailbox_new( strdup( name.latin1() ),
                                 strdup( mail.latin1() ) );
 }
 
 mailimf_fields *Generatemail::createImfFields(const Opie::Core::OSmartPointer<Mail>&mail )
 {
     mailimf_fields *fields = NULL;
     mailimf_field *xmailer = NULL;
     mailimf_mailbox *sender=0,*fromBox=0;
     mailimf_mailbox_list *from=0;
     mailimf_address_list *to=0, *cc=0, *bcc=0, *reply=0;
     clist*in_reply_to = 0;
     char *subject = strdup( mail->getSubject().latin1() );
     int err;
     int res = 1;
 
     sender = newMailbox( mail->getName(), mail->getMail() );
     if ( sender == NULL ) {
         res = 0;
     }
 
     if (res) {
         fromBox = newMailbox( mail->getName(), mail->getMail() );
     }
     if ( fromBox == NULL ) {
         res = 0;
     }
 
     if (res) {
         from = mailimf_mailbox_list_new_empty();
     }
     if ( from == NULL ) {
         res = 0;
     }
 
     if (res && from) {
         err = mailimf_mailbox_list_add( from, fromBox );
         if ( err != MAILIMF_NO_ERROR ) {
             res = 0;
         }
     }
 
     if (res) to = parseAddresses( mail->getTo() );
     if (res) cc = parseAddresses( mail->getCC() );
     if (res) bcc = parseAddresses( mail->getBCC() );
     if (res) reply = parseAddresses( mail->getReply() );
 
     if (res && mail->Inreply().count()>0) {
         in_reply_to = clist_new();
         char*c_reply;
         unsigned int nsize = 0;
         for (QStringList::ConstIterator it=mail->Inreply().begin();
              it != mail->Inreply().end();++it) {
             if ((*it).isEmpty())
                 continue;
             QString h((*it));
             while (h.length()>0 && h[0]=='<') {
                 h.remove(0,1);
             }
             while (h.length()>0 && h[h.length()-1]=='>') {
                 h.remove(h.length()-1,1);
             }
             if (h.isEmpty()) continue;
             nsize = strlen(h.latin1());
             /* yes! must be malloc! */
             c_reply = (char*)malloc( (nsize+1)*sizeof(char));
             memset(c_reply,0,nsize+1);
             memcpy(c_reply,h.latin1(),nsize);
             clist_append(in_reply_to,c_reply);
         }
     }
 
     if (res) {
         fields = mailimf_fields_new_with_data( from, sender, reply, to, cc, bcc,
                                            in_reply_to, NULL, subject );
         if ( fields == NULL ) {
             res = 0;
         }
     }
     if (res) xmailer = mailimf_field_new_custom( strdup( "User-Agent" ),
                                         strdup( USER_AGENT ) );
     if ( xmailer == NULL ) {
         res = 0;
     } else {
         err = mailimf_fields_add( fields, xmailer );
         if ( err != MAILIMF_NO_ERROR ) {
             res = 0;
         }
     }
     if (!res ) {
         if (xmailer) {
             mailimf_field_free( xmailer );
             xmailer = NULL;
         }
         if (fields) {
             mailimf_fields_free( fields );
             fields = NULL;
         } else {
             if (reply)
                 mailimf_address_list_free( reply );
             if (bcc)
                 mailimf_address_list_free( bcc );
             if (cc)
                 mailimf_address_list_free( cc );
             if (to)
                 mailimf_address_list_free( to );
             if (fromBox) {
                 mailimf_mailbox_free( fromBox );
             } else if (from) {
                 mailimf_mailbox_list_free( from );
             }
             if (sender) {
                 mailimf_mailbox_free( sender );
             }
             if (subject) {
                 free( subject );
             }
         }
     }
     return fields;
 }
 
 mailmime *Generatemail::createMimeMail(const Opie::Core::OSmartPointer<Mail> &mail ) {
     mailmime *message, *txtPart;
     mailimf_fields *fields;
     int err;
 
     fields = createImfFields( mail );
     if ( fields == NULL )
         goto err_free;
 
     message = mailmime_new_message_data( NULL );
     if ( message == NULL )
         goto err_free_fields;
 
     mailmime_set_imf_fields( message, fields );
 
     txtPart = buildTxtPart( mail->getMessage() );
 
     if ( txtPart == NULL )
         goto err_free_message;
 
     err = mailmime_smart_add_part( message, txtPart );
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_txtPart;
 
     addFileParts( message, mail->getAttachments() );
 
     return message;         // Success :)
 
 err_free_txtPart:
     mailmime_free( txtPart );
 err_free_message:
     mailmime_free( message );
 err_free_fields:
     mailimf_fields_free( fields );
 err_free:
     ;
 
     return NULL;            // Error :(
 }
 
 clist *Generatemail::createRcptList( mailimf_fields *fields ) {
     clist *rcptList;
     mailimf_field *field;
 
     rcptList = esmtp_address_list_new();
 
     field = getField( fields, MAILIMF_FIELD_TO );
     if ( field && (field->fld_type == MAILIMF_FIELD_TO)
             && field->fld_data.fld_to->to_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_to->to_addr_list );
     }
 
     field = getField( fields, MAILIMF_FIELD_CC );
     if ( field && (field->fld_type == MAILIMF_FIELD_CC)
             && field->fld_data.fld_cc->cc_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_cc->cc_addr_list );
     }
 
     field = getField( fields, MAILIMF_FIELD_BCC );
     if ( field && (field->fld_type == MAILIMF_FIELD_BCC)
             && field->fld_data.fld_bcc->bcc_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_bcc->bcc_addr_list );
     }
 
     return rcptList;
 }
diff --git a/kmicromail/libmailwrapper/imapwrapper.cpp b/kmicromail/libmailwrapper/imapwrapper.cpp
index ae667ec..d90a8d2 100644
--- a/kmicromail/libmailwrapper/imapwrapper.cpp
+++ b/kmicromail/libmailwrapper/imapwrapper.cpp
@@ -1,883 +1,884 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 #include <stdlib.h>
 #include <libetpan/libetpan.h>
 #include <qpe/global.h>
 #include <qapplication.h>
 #include "imapwrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 #include <qprogressbar.h>
 #include "genericwrapper.h"
 #include <kglobal.h>
 
 using namespace Opie::Core;
 int IMAPwrapper::mMax = 0;
 int IMAPwrapper::mCurrent = 0;
 
 IMAPwrapper::IMAPwrapper( IMAPaccount *a )
     : AbstractMail()
 {
     account = a;
     m_imap = 0;
     m_Lastmbox = "";
     mCurrent = 0;
     mMax = 0;
 }
 
 IMAPwrapper::~IMAPwrapper()
 {
     logout();
 }
 
 /* to avoid to often select statements in loops etc.
    we trust that we are logged in and connection is established!*/
 int IMAPwrapper::selectMbox(const QString&mbox)
 {
     if (mbox == m_Lastmbox) {
         return MAILIMAP_NO_ERROR;
     }
     int err = mailimap_select( m_imap, (char*)mbox.latin1());
     if ( err != MAILIMAP_NO_ERROR ) {
         m_Lastmbox = "";
         return err;
     }
     m_Lastmbox = mbox;
     return err;
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     //qDebug("imap progress %d of %d ",current,maximum  );
     //Global::statusMessage(i18n("Downloading message %1 of %2").arg( current).arg(maximum));
     //qApp->processEvents()
     static int last = 0;
     if ( last != current )
         IMAPwrapper::progress();
     last = current;
 }
 void IMAPwrapper::progress( QString m )
 {
  
     static QString mProgrMess;
     if ( m != QString::null ) {
         mProgrMess = m;
         mCurrent = 1;
         return;
     }
     QString mess;
     //qDebug("progress ");
     if (  mMax ) mess = mProgrMess +i18n(" message %1 of %2").arg( mCurrent++).arg(mMax);
     else mess = mProgrMess +i18n(" message %1").arg( mCurrent++);
     Global::statusMessage(mess);
     //qDebug("Progress %s %s", mess.latin1(), m.latin1());
     qApp->processEvents();
 }
 bool IMAPwrapper::start_tls(bool force_tls)
 {
     int err;
-    bool try_tls;
+    bool try_tls = force_tls;
     mailimap_capability_data * cap_data = 0;
 
     err = mailimap_capability(m_imap,&cap_data);
     if (err != MAILIMAP_NO_ERROR) {
         Global::statusMessage("error getting capabilities!");
         return false;
     }
     clistiter * cur;
     for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) {
         struct mailimap_capability * cap;
         cap  = (struct mailimap_capability *)clist_content(cur);
         if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) {
             if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) {
                 try_tls = true;
                 break;
             }
         }
     }
     if (cap_data) {
         mailimap_capability_data_free(cap_data);
     }
     if (try_tls) {
         err =  mailimap_starttls(m_imap);
         if (err != MAILIMAP_NO_ERROR && force_tls) {
             Global::statusMessage(i18n("Server has no TLS support!"));
             try_tls = false;
         } else {
             mailstream_low * low;
             mailstream_low * new_low;
             low = mailstream_get_low(m_imap->imap_stream);
             if (!low) {
                 try_tls = false;
             } else {
                 int fd = mailstream_low_get_fd(low);
                 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
                     mailstream_low_free(low);
                     mailstream_set_low(m_imap->imap_stream, new_low);
                 } else {
                     try_tls = false;
                 }
             }
         }
    }
    return try_tls;
 }
 
 void IMAPwrapper::login()
 {
     QString server, user, pass;
     uint16_t port;
     int err = MAILIMAP_NO_ERROR;
 
     if (account->getOffline()) return;
     /* we are connected this moment */
     /* TODO: setup a timer holding the line or if connection closed - delete the value */
     if (m_imap) {
         err = mailimap_noop(m_imap);
         if (err!=MAILIMAP_NO_ERROR) {
             logout();
         } else {
             mailstream_flush(m_imap->imap_stream);
             return;
         }
     }
     server = account->getServer();
     port = account->getPort().toUInt();
     if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) {
       LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true );
       login.show();
       if ( QDialog::Accepted == login.exec() ) {
         // ok
         user = login.getUser();
         pass = login.getPassword();
       } else {
         // cancel
         return;
       }
     } else {
       user = account->getUser();
       pass = account->getPassword();
     }
 
     m_imap = mailimap_new( 20, &imap_progress );
 
     /* connect */
     bool ssl = false;
     bool try_tls = false;
     bool force_tls = false;
 
     if  ( account->ConnectionType() == 2 ) {
         ssl = true;
     }
     if (account->ConnectionType()==1) {
         force_tls = true;
     }
 
     if ( ssl ) {
         qDebug("using ssl ");
         err = mailimap_ssl_connect( m_imap, (char*)server.latin1(), port );
         qDebug("back ");
     } else {
         err = mailimap_socket_connect( m_imap, (char*)server.latin1(), port );
     }
 
     if ( err != MAILIMAP_NO_ERROR &&
          err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
          err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
          QString failure = "";
          if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) {
             failure="Connection refused";
          } else {
             failure="Unknown failure";
          }
          Global::statusMessage(i18n("error connecting imap server: %1").arg(failure));
          mailimap_free( m_imap );
          m_imap = 0;
          return;
     }
 
     if (!ssl) {
         try_tls = start_tls(force_tls);
     }
 
     bool ok = true;
     if (force_tls && !try_tls) {
         Global::statusMessage(i18n("Server has no TLS support!"));
         ok = false;
     }
 
 
     /* login */
 
     if (ok) {
         err = mailimap_login_simple( m_imap, (char*)user.latin1(), (char*)pass.latin1() );
         if ( err != MAILIMAP_NO_ERROR ) {
             Global::statusMessage(i18n("error logging in imap server: %1").arg(m_imap->imap_response));
             ok = false;
         }
     }
     if (!ok) {
         err = mailimap_close( m_imap );
         mailimap_free( m_imap );
         m_imap = 0;
     }
 }
 
 void IMAPwrapper::logout()
 {
     int err = MAILIMAP_NO_ERROR;
     if (!m_imap) return;
     err = mailimap_logout( m_imap );
     err = mailimap_close( m_imap );
     mailimap_free( m_imap );
     m_imap = 0;
     m_Lastmbox = "";
 }
 
 void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> > &target , int maxSizeInKb)
 {
 
     int tryAgain = 1;
     while ( tryAgain >= 0 ) {
         int err = MAILIMAP_NO_ERROR;
         clist *result = 0;
         clistcell *current;
         mailimap_fetch_type *fetchType = 0;
         mailimap_set *set = 0;
 
         login();
         if (!m_imap) {
             return;
         }
         /* select mailbox READONLY for operations */
         err = selectMbox(mailbox);
         if ( err != MAILIMAP_NO_ERROR ) {
             return;
         }
 
         int last = m_imap->imap_selection_info->sel_exists;
 
         if (last == 0) {
             Global::statusMessage(i18n("Mailbox has no mails"));
             return;
         } else {
         }
         progress( i18n("Fetch "));     
         mMax = last;
         //qDebug("last %d ", last);
         Global::statusMessage(i18n("Fetching header list"));
         qApp->processEvents();
         /* the range has to start at 1!!! not with 0!!!! */
         //LR the access to web.de imap server is no working with value 1
         //qDebug("interval %d - %d ", tryAgain, last-1+tryAgain  );
         set = mailimap_set_new_interval( tryAgain, last );
         fetchType = mailimap_fetch_type_new_fetch_att_list_empty();
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size());
 
         err = mailimap_fetch( m_imap, set, fetchType, &result );
         mailimap_set_free( set );
         mailimap_fetch_type_free( fetchType );
 
         QString date,subject,from;
 
         if ( err == MAILIMAP_NO_ERROR ) {
             tryAgain = -1;
             mailimap_msg_att * msg_att;
             int i = 0;
             for (current = clist_begin(result); current != 0; current=clist_next(current)) {
                 ++i;
                 //qDebug("iii %d ",i);
                 msg_att = (mailimap_msg_att*)current->data;
                 RecMail*m = parse_list_result(msg_att);
                 if (m) {
                     if ( maxSizeInKb == 0 || m->Msgsize()<=maxSizeInKb*1024 ) { 
                         m->setNumber(i);
                         m->setMbox(mailbox);
                         m->setWrapper(this);
                         target.append(m);
                     }
                 }
             }
             Global::statusMessage(i18n("Mailbox has %1 mails").arg(target.count()));
         } else {
             --tryAgain;
             --tryAgain;//disabled tryagain by adding this line
             if ( tryAgain < 0 )
                 Global::statusMessage(i18n("Error fetching headers: %1").arg(m_imap->imap_response));
             else
                 qDebug("try again... ");
         }
     
         if (result) mailimap_fetch_list_free(result);
     }
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
 {
     const char *path, *mask;
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current = 0;
     clistcell*cur_flag = 0;
     mailimap_mbx_list_flags*bflags = 0;
 
     QValueList<FolderP>* folders = new QValueList<FolderP>();
     login();
     if (!m_imap) {
         return folders;
     }
 
 /*
  * First we have to check for INBOX 'cause it sometimes it's not inside the path.
  * We must not forget to filter them out in next loop!
  * it seems like ugly code. and yes - it is ugly code. but the best way.
  */
     Global::statusMessage(i18n("Fetching folder list"));
     qApp->processEvents();
     QString temp;
     mask = "INBOX" ;
     mailimap_mailbox_list *list;
     err = mailimap_list( m_imap, (char*)"", (char*)mask, &result );
     QString del;
     bool selectable = true;
     bool no_inferiors = false;
     if ( err == MAILIMAP_NO_ERROR ) {
         current = result->first;
         for ( int i = result->count; i > 0; i-- ) {
             list = (mailimap_mailbox_list *) current->data;
             // it is better use the deep copy mechanism of qt itself
             // instead of using strdup!
             temp = list->mb_name;
             del = list->mb_delimiter;
             current = current->next;
             if ( (bflags = list->mb_flag) ) {
                 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&&
                             bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT);
                 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) {
                     if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) {
                         no_inferiors = true;
                     }
                 }
             }
             folders->append( new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix()));
         }
     } else {
         qDebug("error fetching folders: ");
       
     }
     mailimap_list_result_free( result );
 
 /*
  * second stage - get the other then inbox folders
  */
     mask = "*" ;
     path = account->getPrefix().latin1();
     if (!path) path = "";
     err = mailimap_list( m_imap, (char*)path, (char*)mask, &result );
     if ( err == MAILIMAP_NO_ERROR ) {
         current = result->first;
         for ( current=clist_begin(result);current!=NULL;current=clist_next(current)) {
             no_inferiors = false;
             list = (mailimap_mailbox_list *) current->data;
             // it is better use the deep copy mechanism of qt itself
             // instead of using strdup!
             temp = list->mb_name;
             if (temp.lower()=="inbox")
                 continue;
             if (temp.lower()==account->getPrefix().lower())
                 continue;
             if ( (bflags = list->mb_flag) ) {
                 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&&
                             bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT);
                 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) {
                     if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) {
                         no_inferiors = true;
                     }
                 }
             }
             del = list->mb_delimiter;
             folders->append(new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix()));
         }
     } else {
         qDebug("error fetching folders  ");
      
     }
     if (result) mailimap_list_result_free( result );
     return folders;
 }
 
 RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att)
 {
     RecMail * m = 0;
     mailimap_msg_att_item *item=0;
     clistcell *current,*c,*cf;
     mailimap_msg_att_dynamic*flist;
     mailimap_flag_fetch*cflag;
     int size;
     QBitArray mFlags(7);
     QStringList addresslist;
 
     if (!m_att) {
         return m;
     }
     m = new RecMail();
     for (c = clist_begin(m_att->att_list); c!=NULL;c=clist_next(c) ) {
         current = c;
         size = 0;
         item = (mailimap_msg_att_item*)current->data;
         if ( !item )
             continue;
         if (item->att_type!=MAILIMAP_MSG_ATT_ITEM_STATIC) {
             flist = (mailimap_msg_att_dynamic*)item->att_data.att_dyn;
             if (!flist || !flist->att_list) {
                 continue;
             }
             cf = flist->att_list->first;
             if( ! cf )
             for (cf = clist_begin(flist->att_list); cf!=NULL; cf = clist_next(cf)) {
                 cflag = (mailimap_flag_fetch*)cf->data;
                 if( ! cflag )
                     qDebug("imap:not cflag ");
                 if (cflag->fl_type==MAILIMAP_FLAG_FETCH_OTHER && cflag->fl_flag!=0) {
                     switch (cflag->fl_flag->fl_type) {
                     case MAILIMAP_FLAG_ANSWERED:  /* \Answered flag */
                         mFlags.setBit(FLAG_ANSWERED);
                         break;
                     case MAILIMAP_FLAG_FLAGGED:   /* \Flagged flag */
                         mFlags.setBit(FLAG_FLAGGED);
                         break;
                     case MAILIMAP_FLAG_DELETED:   /* \Deleted flag */
                         mFlags.setBit(FLAG_DELETED);
                         break;
                     case MAILIMAP_FLAG_SEEN:      /* \Seen flag */
                         mFlags.setBit(FLAG_SEEN);
                         break;
                     case MAILIMAP_FLAG_DRAFT:     /* \Draft flag */
                         mFlags.setBit(FLAG_DRAFT);
                         break;
                     case MAILIMAP_FLAG_KEYWORD:   /* keyword flag */
                         break;
                     case MAILIMAP_FLAG_EXTENSION: /* \extension flag */
                         break;
                     default:
                         break;
                     }
                 } else if (cflag->fl_type==MAILIMAP_FLAG_FETCH_RECENT) {
                     mFlags.setBit(FLAG_RECENT);
                 }
             }
             continue;
         }
         if ( item->att_data.att_static == NULL )
             continue;
         if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_ENVELOPE) {
             mailimap_envelope * head = item->att_data.att_static->att_data.att_env;
             if ( head == NULL )
                 continue;
             if ( head->env_date != NULL ) {
                 m->setDate(head->env_date);
-                struct mailimf_date_time result; 
-                struct mailimf_date_time* date = &result;
+                //struct mailimf_date_time result; 
+                struct mailimf_date_time* date;// = &result;
                 struct mailimf_date_time **re = &date;
                 size_t length = m->getDate().length();
                 size_t  index = 0;
                 if (  mailimf_date_time_parse(head->env_date, length,&index, re ) == MAILIMF_NO_ERROR ) {
                     QDateTime dt = Genericwrapper::parseDateTime( date );
                     QString ret;
                     if ( dt.date() ==  QDate::currentDate () )
                         ret = KGlobal::locale()->formatTime( dt.time(),true);
                     else {
                         ret = KGlobal::locale()->formatDateTime( dt,true,true);
                     }
                     m->setDate( ret );
                     char tmp[20];
                     snprintf( tmp, 20,  "%04i-%02i-%02i %02i:%02i:%02i",
                               dt.date().year(),dt.date().month(), dt.date().day(), dt.time().hour(), dt.time().minute(), dt.time().second() );
                     //qDebug("%d iso %s %s ", date->dt_zone, tmp, head->env_date);
                     m->setIsoDate( QString( tmp ) );
+                    mailimf_date_time_free ( date );
                 } else {
                     m->setIsoDate(head->env_date);
                 }
             }
             if ( head->env_subject != NULL ) 
                 m->setSubject(convert_String((const char*)head->env_subject));
             //m->setSubject(head->env_subject);
             if (head->env_from!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_from->frm_list);
                 if (addresslist.count()) {
                     m->setFrom(addresslist.first());
                 }
             }
             if (head->env_to!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_to->to_list);
                 m->setTo(addresslist);
             }
             if (head->env_cc!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_cc->cc_list);
                 m->setCC(addresslist);
             }
             if (head->env_bcc!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_bcc->bcc_list);
                 m->setBcc(addresslist);
             }
             /* reply to address, eg. email. */
             if (head->env_reply_to!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_reply_to->rt_list);
                 if (addresslist.count()) {
                     m->setReplyto(addresslist.first());
                 }
             }
             if (head->env_in_reply_to!=NULL) {
                 QString h(head->env_in_reply_to);
                 while (h.length()>0 && h[0]=='<') {
                     h.remove(0,1);
                 }
                 while (h.length()>0 && h[h.length()-1]=='>') {
                     h.remove(h.length()-1,1);
                 }
                 if (h.length()>0) {
                     m->setInreply(QStringList(h));
                 }
             }
             if (head->env_message_id != NULL) {
                 m->setMsgid(QString(head->env_message_id));
             }
         } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_INTERNALDATE) {
 #if 0
             mailimap_date_time*d = item->att_data.att_static->att_data.att_internal_date;
             QDateTime da(QDate(d->dt_year,d->dt_month,d->dt_day),QTime(d->dt_hour,d->dt_min,d->dt_sec));
             qDebug("time %s ",da.toString().latin1() );
 #endif
         } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_RFC822_SIZE) {
             size = item->att_data.att_static->att_data.att_rfc822_size;
         }
     }
     /* msg is already deleted */
     if (mFlags.testBit(FLAG_DELETED) && m) {
         delete m;
         m = 0;
     }
     if (m) {
         m->setFlags(mFlags);
         m->setMsgsize(size);
     }
     return m;
 }
 
 RecBodyP IMAPwrapper::fetchBody(const RecMailP&mail)
 {
     RecBodyP body = new RecBody();
     const char *mb;
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current;
     mailimap_fetch_att *fetchAtt = 0;
     mailimap_fetch_type *fetchType = 0;
     mailimap_set *set = 0;
     mailimap_body*body_desc = 0;
 
     mb = mail->getMbox().latin1();
 
     login();
     if (!m_imap) {
         return body;
     }
     err = selectMbox(mail->getMbox());
     if ( err != MAILIMAP_NO_ERROR ) {
         return body;
     }
 
     /* the range has to start at 1!!! not with 0!!!! */
     set = mailimap_set_new_interval( mail->getNumber(),mail->getNumber() );
     fetchAtt = mailimap_fetch_att_new_bodystructure();
     fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt);
     err = mailimap_fetch( m_imap, set, fetchType, &result );
     mailimap_set_free( set );
     mailimap_fetch_type_free( fetchType );
 
     if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) {
         mailimap_msg_att * msg_att;
         msg_att = (mailimap_msg_att*)current->data;
         mailimap_msg_att_item*item = (mailimap_msg_att_item*)msg_att->att_list->first->data;
         QValueList<int> path;
         body_desc = item->att_data.att_static->att_data.att_body;
         traverseBody(mail,body_desc,body,0,path);
     } else {
         //odebug << "error fetching body: " << m_imap->imap_response << "" << oendl; 
     }
     if (result) mailimap_fetch_list_free(result);
     return body;
 }
 
 QStringList IMAPwrapper::address_list_to_stringlist(clist*list)
 {
     QStringList l;
     QString from;
     bool named_from;
     clistcell *current = NULL;
     mailimap_address * current_address=NULL;
     if (!list) {
         return l;
     }
     unsigned int count = 0;
     for (current=clist_begin(list);current!= NULL;current=clist_next(current)) {
         from = "";
         named_from = false;
         current_address=(mailimap_address*)current->data;
         if (current_address->ad_personal_name){
             from+=convert_String((const char*)current_address->ad_personal_name);
             from+=" ";
             named_from = true;
         }
         if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
             from+="<";
         }
         if (current_address->ad_mailbox_name) {
             from+=QString(current_address->ad_mailbox_name);
             from+="@";
         }
         if (current_address->ad_host_name) {
              from+=QString(current_address->ad_host_name);
         }
         if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
            from+=">";
         }
         l.append(QString(from));
         if (++count > 99) {
             break;
         }
     }
     return l;
 }
 
 encodedString*IMAPwrapper::fetchRawPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call)
 {
     encodedString*res=new encodedString;
     int err;
     mailimap_fetch_type *fetchType;
     mailimap_set *set;
     clistcell*current,*cur;
     mailimap_section_part * section_part =  0;
     mailimap_section_spec * section_spec =  0;
     mailimap_section * section = 0;
     mailimap_fetch_att * fetch_att = 0;
 
     login();
     if (!m_imap) {
         return res;
     }
     if (!internal_call) {
         err = selectMbox(mail->getMbox());
         if ( err != MAILIMAP_NO_ERROR ) {
             return res;
         }
     }
     set = mailimap_set_new_single(mail->getNumber());
 
     clist*id_list = 0;
 
     /* if path == empty then its a request for the whole rfc822 mail and generates
        a "fetch <id> (body[])" statement on imap server */
     if (path.count()>0 ) {
         id_list = clist_new();
         for (unsigned j=0; j < path.count();++j) {
             uint32_t * p_id = (uint32_t *)malloc(sizeof(*p_id));
             *p_id = path[j];
             clist_append(id_list,p_id);
         }
         section_part =  mailimap_section_part_new(id_list);
         section_spec =  mailimap_section_spec_new(MAILIMAP_SECTION_SPEC_SECTION_PART, NULL, section_part, NULL);
     }
 
     section =  mailimap_section_new(section_spec);
     fetch_att = mailimap_fetch_att_new_body_section(section);
     fetchType = mailimap_fetch_type_new_fetch_att(fetch_att);
 
     clist*result = 0;
 
     err = mailimap_fetch( m_imap, set, fetchType, &result );
     mailimap_set_free( set );
     mailimap_fetch_type_free( fetchType );
 
     if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) {
         mailimap_msg_att * msg_att;
         msg_att = (mailimap_msg_att*)current->data;
         mailimap_msg_att_item*msg_att_item;
         for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; cur = clist_next(cur)) {
             msg_att_item = (mailimap_msg_att_item*)clist_content(cur);
             if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) {
                 if (msg_att_item->att_data.att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) {
                     char*text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part;
                     /* detach - we take over the content */
                     msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = 0L;
                     res->setContent(text,msg_att_item->att_data.att_static->att_data.att_body_section->sec_length);
                 }
             }
         }
     } else {
         ;//odebug << "error fetching text: " << m_imap->imap_response << "" << oendl; 
     }
     if (result) mailimap_fetch_list_free(result);
     return res;
 }
 
 /* current_recursion is for recursive calls.
    current_count means the position inside the internal loop! */
 void IMAPwrapper::traverseBody(const RecMailP&mail,mailimap_body*body,RecBodyP&target_body,
     int current_recursion,QValueList<int>recList,int current_count)
 {
     if (!body || current_recursion>=10) {
         return;
     }
     switch (body->bd_type) {
     case MAILIMAP_BODY_1PART:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         RecPartP currentPart = new RecPart();
         mailimap_body_type_1part*part1 = body->bd_data.bd_body_1part;
         QString id("");
         currentPart->setPositionlist(countlist);
         for (unsigned int j = 0; j < countlist.count();++j) {
             id+=(j>0?" ":"");
             id+=QString("%1").arg(countlist[j]);
         }
         //odebug << "ID = " << id.latin1() << "" << oendl; 
         currentPart->setIdentifier(id);
         fillSinglePart(currentPart,part1);
         /* important: Check for is NULL 'cause a body can be empty!
            And we put it only into the mail if it is the FIRST part */
         if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_TEXT && target_body->Bodytext().isNull() && countlist[0]==1) {
             QString body_text = fetchTextPart(mail,countlist,true,currentPart->Encoding());
             //qDebug("encoding %d text %s ",currentPart->Encoding().latin1(), body_text.latin1() );
             target_body->setDescription(currentPart);
             target_body->setBodytext(body_text);
             if (countlist.count()>1) {
                 target_body->addPart(currentPart);
             }
         } else {
             target_body->addPart(currentPart);
         }
         if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_MSG) {
             traverseBody(mail,part1->bd_data.bd_type_msg->bd_body,target_body,current_recursion+1,countlist);
         }
     }
     break;
     case MAILIMAP_BODY_MPART:
     {
         QValueList<int>countlist = recList;
         clistcell*current=0;
         mailimap_body*current_body=0;
         unsigned int ccount = 1;
         mailimap_body_type_mpart*mailDescription = body->bd_data.bd_body_mpart;
         for (current=clist_begin(mailDescription->bd_list);current!=0;current=clist_next(current)) {
             current_body = (mailimap_body*)current->data;
             if (current_body->bd_type==MAILIMAP_BODY_MPART) {
                 RecPartP targetPart = new RecPart();
                 targetPart->setType("multipart");
                 fillMultiPart(targetPart,mailDescription);
                 countlist.append(current_count);
                 targetPart->setPositionlist(countlist);
                 target_body->addPart(targetPart);
                 QString id("");
                 for (unsigned int j = 0; j < countlist.count();++j) {
                     id+=(j>0?" ":"");
                     id+=QString("%1").arg(countlist[j]);
                 }
                 // odebug << "ID(mpart) = " << id.latin1() << "" << oendl; 
             }
             traverseBody(mail,current_body,target_body,current_recursion+1,countlist,ccount);
             if (current_body->bd_type==MAILIMAP_BODY_MPART) {
                 countlist = recList;
             }
             ++ccount;
         }
     }
     break;
     default:
     break;
     }
 }
 
 void IMAPwrapper::fillSinglePart(RecPartP&target_part,mailimap_body_type_1part*Description)
 {
     if (!Description) {
         return;
     }
     switch (Description->bd_type) {
         case MAILIMAP_BODY_TYPE_1PART_TEXT:
             target_part->setType("text");
             fillSingleTextPart(target_part,Description->bd_data.bd_type_text);
             break;
         case MAILIMAP_BODY_TYPE_1PART_BASIC:
             fillSingleBasicPart(target_part,Description->bd_data.bd_type_basic);
             break;
         case MAILIMAP_BODY_TYPE_1PART_MSG:
             target_part->setType("message");
             fillSingleMsgPart(target_part,Description->bd_data.bd_type_msg);
             break;
         default:
             break;
     }
 }
 
 void IMAPwrapper::fillSingleTextPart(RecPartP&target_part,mailimap_body_type_text*which)
 {
     if (!which) {
         return;
     }
     QString sub;
     sub = which->bd_media_text;
     //odebug << "Type= text/" << which->bd_media_text << "" << oendl; 
     target_part->setSubtype(sub.lower());
     target_part->setLines(which->bd_lines);
     fillBodyFields(target_part,which->bd_fields);
 }
 
 void IMAPwrapper::fillSingleMsgPart(RecPartP&target_part,mailimap_body_type_msg*which)
 {
     if (!which) {
         return;
     }
     target_part->setSubtype("rfc822");
     //odebug << "Message part" << oendl; 
     /* we set this type to text/plain */
     target_part->setLines(which->bd_lines);
     fillBodyFields(target_part,which->bd_fields);
 }
 
 void IMAPwrapper::fillMultiPart(RecPartP&target_part,mailimap_body_type_mpart*which)
 {
     if (!which) return;
     QString sub = which->bd_media_subtype;
     target_part->setSubtype(sub.lower());
     if (which->bd_ext_mpart && which->bd_ext_mpart->bd_parameter && which->bd_ext_mpart->bd_parameter->pa_list) {
         clistcell*cur = 0;
         mailimap_single_body_fld_param*param=0;
         for (cur = clist_begin(which->bd_ext_mpart->bd_parameter->pa_list);cur!=NULL;cur=clist_next(cur)) {
             param = (mailimap_single_body_fld_param*)cur->data;
             if (param) {
                 target_part->addParameter(QString(param->pa_name).lower(),QString(param->pa_value));
             }
         }
     }
 }
 
 void IMAPwrapper::fillSingleBasicPart(RecPartP&target_part,mailimap_body_type_basic*which)
 {
     if (!which) {
         return;
     }
     QString type,sub;
     switch (which->bd_media_basic->med_type) {
     case MAILIMAP_MEDIA_BASIC_APPLICATION:
         type = "application";
         break;
     case MAILIMAP_MEDIA_BASIC_AUDIO:
         type = "audio";
         break;
     case MAILIMAP_MEDIA_BASIC_IMAGE:
         type = "image";
         break;
diff --git a/kmicromail/libmailwrapper/settings.cpp b/kmicromail/libmailwrapper/settings.cpp
index 5d2c0ad..04afe7c 100644
--- a/kmicromail/libmailwrapper/settings.cpp
+++ b/kmicromail/libmailwrapper/settings.cpp
@@ -1,407 +1,408 @@
 #include <stdlib.h>
 #include <qdir.h>
 
 //#include <opie2/odebug.h>
 #include <kconfig.h>
 
 #include <kstandarddirs.h>
 #include "settings.h"
 //#include "defines.h"
 
 #define IMAP_PORT           "143"
 #define IMAP_SSL_PORT       "993"
 #define SMTP_PORT           "25"
 #define SMTP_SSL_PORT       "465"
 #define POP3_PORT           "110"
 #define POP3_SSL_PORT       "995"
 #define NNTP_PORT           "119"
 #define NNTP_SSL_PORT       "563"
 
 
 Settings::Settings()
     : QObject()
-{
+{  
+    accounts.setAutoDelete( true ); ;
    updateAccounts();
    //qDebug("++++++++++++++++++new settings ");
 }
 
 void Settings::checkDirectory()
 {
     return;
     locateLocal("data", "kopiemail" );
     /*
     if ( !QDir( (QString) getenv( "HOME" ) + "/Applications/opiemail/" ).exists() ) {
         system( "mkdir -p $HOME/Applications/opiemail" );
         qDebug("$HOME/Applications/opiemail created ");
     }
     */
 }
 
 QList<Account> Settings::getAccounts()
 {
     return accounts;
 }
 
 void Settings::addAccount( Account *account )
 {
     accounts.append( account );
 }
 
 void Settings::delAccount( Account *account )
 {
     accounts.remove( account );
     account->remove();
 }
 
 void Settings::updateAccounts()
 {
     accounts.clear();
     QDir dir( locateLocal("data", "kopiemail" ) );
     QStringList::Iterator it;
 
     QStringList imap = dir.entryList( "imap-*" );
     for ( it = imap.begin(); it != imap.end(); it++ ) {
         IMAPaccount *account = new IMAPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList pop3 = dir.entryList( "pop3-*" );
     for ( it = pop3.begin(); it != pop3.end(); it++ ) {
         POP3account *account = new POP3account( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList smtp = dir.entryList( "smtp-*" );
     for ( it = smtp.begin(); it != smtp.end(); it++ ) {
         SMTPaccount *account = new SMTPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList nntp = dir.entryList( "nntp-*" );
     for ( it = nntp.begin(); it != nntp.end(); it++ ) {
         NNTPaccount *account = new NNTPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     readAccounts();
 }
 
 void Settings::saveAccounts()
 {
     checkDirectory();
     Account *it;
 
     for ( it = accounts.first(); it; it = accounts.next() ) {
         it->save();
     }
 }
 
 void Settings::readAccounts()
 {
     checkDirectory();
     Account *it;
 
     for ( it = accounts.first(); it; it = accounts.next() ) {
         it->read();
     }
 }
 
 Account::Account()
 {
     accountName = "changeMe";
     type = MAILLIB::A_UNDEFINED;
     ssl = false;
     connectionType = 1;
     offline = false;  
     maxMailSize = 0;
     lastFetch;
     leaveOnServer = false;
 }
 
 void Account::remove()
 {
     QFile file( getFileName() );
     file.remove();
 }
 
 void Account::setPasswordList(const QStringList &str)
 {
     password = "";
     int i;
     for ( i = 0; i < str.count()  ; ++i ) {
         QChar c ( (str[i].toUInt()-131)/(str.count()- (i%3)));
         password.append( c );
     }
     //qDebug("password %s ", password.latin1());
 }
 QStringList Account::getPasswordList()
 {
     int i;
     int len = password.length();
     QStringList str;
     
     for ( i = 0; i < len  ; ++i ) {
         int val = password.at(i).unicode()*(len-(i%3))+131;
         str.append( QString::number( val ) );
         // qDebug("append %s ", str[i].latin1());
     }
     return str;
 }
 
 IMAPaccount::IMAPaccount()
     : Account()
 {
     file = IMAPaccount::getUniqueFileName();
     accountName = "New IMAP Account";
     ssl = false;
     connectionType = 1;
     type = MAILLIB::A_IMAP;
     port = IMAP_PORT;
 }
 
 IMAPaccount::IMAPaccount( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New IMAP Account";
     ssl = false;
     connectionType = 1;
     type = MAILLIB::A_IMAP;
     port = IMAP_PORT;
 }
 
 QString IMAPaccount::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( locateLocal("data", "kopiemail" ) );
 
     QStringList imap = dir.entryList( "imap-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "imap-" + unique ) > 0 );
 
     return unique;
 }
 
 void IMAPaccount::read()
 {
     KConfig *conf = new KConfig( getFileName() );
     conf->setGroup( "IMAP Account" );
     accountName = conf->readEntry( "Account","" );
     if (accountName.isNull()) accountName = "";
     server = conf->readEntry( "Server","" );
     if (server.isNull()) server="";
     port = conf->readEntry( "Port","" );
     if (port.isNull()) port="143";
     connectionType = conf->readNumEntry( "ConnectionType" );
     ssl = conf->readBoolEntry( "SSL",false );
     user = conf->readEntry( "User","" );
     if (user.isNull()) user = "";
     //password = conf->readEntryCrypt( "Password","" );
     setPasswordList( conf->readListEntry( "FolderHistory"));
     if (password.isNull()) password = "";
     prefix = conf->readEntry("MailPrefix","");
     if (prefix.isNull()) prefix = "";
     offline = conf->readBoolEntry("Offline",false);
     localFolder = conf->readEntry( "LocalFolder" );
     maxMailSize = conf->readNumEntry( "MaxSize",0 );
     int lf = conf->readNumEntry( "LastFetch",0 );
     QDateTime dt ( QDate ( 2004, 1, 1 ), QTime( 0,0,0) );
     leaveOnServer = conf->readBoolEntry("LeaveOnServer",false);
     if ( lf < 0 ) lf = 0;
     lastFetch = dt.addSecs( lf );
     delete conf;
 }
 
 void IMAPaccount::save()
 {
  
     Settings::checkDirectory();
 
     KConfig *conf = new KConfig( getFileName() );
     conf->setGroup( "IMAP Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "ConnectionType", connectionType );
     conf->writeEntry( "User", user );
     //conf->writeEntryCrypt( "Password", password );
     conf->writeEntry( "FolderHistory",getPasswordList() );
     conf->writeEntry( "MailPrefix",prefix);
     conf->writeEntry( "Offline",offline);
     conf->writeEntry( "LocalFolder", localFolder );
     conf->writeEntry( "MaxSize", maxMailSize );
     QDateTime dt ( QDate ( 2004, 1, 1 ), QTime( 0,0,0) );
     int lf = dt.secsTo ( lastFetch );
     conf->writeEntry( "LastFetch", lf );
     conf->writeEntry( "LeaveOnServer", leaveOnServer);
     conf->sync();
     delete conf;
 }
 
 
 QString IMAPaccount::getFileName()
 {
     return locateLocal("data", "kopiemail" ) +"/imap-" + file;
 }
 
 POP3account::POP3account()
     : Account()
 {
     file = POP3account::getUniqueFileName();
     accountName = "New POP3 Account";
     ssl = false;
     connectionType = 1;
     type = MAILLIB::A_POP3;
     port = POP3_PORT;
 }
 
 POP3account::POP3account( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New POP3 Account";
     ssl = false;
     connectionType = 1;
     type = MAILLIB::A_POP3;
     port = POP3_PORT;
 }
 
 QString POP3account::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( locateLocal("data", "kopiemail" ) );
 
     QStringList imap = dir.entryList( "pop3-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "pop3-" + unique ) > 0 );
 
     return unique;
 }
 
 void POP3account::read()
 {
     KConfig *conf = new KConfig( getFileName());
     conf->setGroup( "POP3 Account" );
     accountName = conf->readEntry( "Account" );
     server = conf->readEntry( "Server" );
     port = conf->readEntry( "Port" );
     ssl = conf->readBoolEntry( "SSL" );
     connectionType = conf->readNumEntry( "ConnectionType" );
     user = conf->readEntry( "User" );
     //password = conf->readEntryCrypt( "Password" );
     setPasswordList( conf->readListEntry( "FolderHistory"));
     offline = conf->readBoolEntry("Offline",false);
     localFolder = conf->readEntry( "LocalFolder" );
     maxMailSize = conf->readNumEntry( "MaxSize",0 );
     int lf = conf->readNumEntry( "LastFetch",0 );
     QDateTime dt ( QDate ( 2004, 1, 1 ), QTime( 0,0,0) );
     leaveOnServer = conf->readBoolEntry("LeaveOnServer",false);
     lastFetch = dt.addSecs( lf );
     delete conf;
 }
 
 void POP3account::save()
 {
     Settings::checkDirectory();
 
     KConfig *conf = new KConfig( getFileName() );
     conf->setGroup( "POP3 Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "ConnectionType", connectionType );
     conf->writeEntry( "User", user );
     //conf->writeEntryCrypt( "Password", password );
     conf->writeEntry( "FolderHistory",getPasswordList() );
     conf->writeEntry( "Offline",offline);
     conf->writeEntry( "LocalFolder", localFolder );
     conf->writeEntry( "MaxSize", maxMailSize );
     QDateTime dt ( QDate ( 2004, 1, 1 ), QTime( 0,0,0) );
     int lf = dt.secsTo ( lastFetch );
     conf->writeEntry( "LastFetch", lf );
     conf->writeEntry( "LeaveOnServer", leaveOnServer);
     conf->sync();
     delete conf;
 }
 
 
 QString POP3account::getFileName()
 {
     return locateLocal("data", "kopiemail" ) +"/pop3-" + file;
 }
 
 SMTPaccount::SMTPaccount()
     : Account()
 {
     file = SMTPaccount::getUniqueFileName();
     accountName = "New SMTP Account";
     ssl = false;
     connectionType = 1;
     login = false;
     useCC = false;
     useBCC = false;
     useReply = false;
     type = MAILLIB::A_SMTP;
     port = SMTP_PORT;
 }
 
 SMTPaccount::SMTPaccount( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New SMTP Account";
     ssl = false;
     connectionType = 1;
     login = false;
     type = MAILLIB::A_SMTP;
     port = SMTP_PORT;
 }
 
 QString SMTPaccount::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( locateLocal("data", "kopiemail" ) );
 
     QStringList imap = dir.entryList( "smtp-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "smtp-" + unique ) > 0 );
 
     return unique;
 }
 
 void SMTPaccount::read()
 {
     KConfig *conf = new KConfig( getFileName() );
     conf->setGroup( "SMTP Account" );
     accountName = conf->readEntry( "Account" );
     server = conf->readEntry( "Server" );
     port = conf->readEntry( "Port" );
     ssl = conf->readBoolEntry( "SSL" );
     connectionType = conf->readNumEntry( "ConnectionType" );
     login = conf->readBoolEntry( "Login" );
     user = conf->readEntry( "User" );
     //password = conf->readEntryCrypt( "Password" );
     setPasswordList( conf->readListEntry( "FolderHistory"));
     delete conf;
 }
 
 void SMTPaccount::save()
 {
     Settings::checkDirectory();
 
     KConfig *conf = new KConfig( getFileName() );
     conf->setGroup( "SMTP Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
diff --git a/kmicromail/opiemail.cpp b/kmicromail/opiemail.cpp
index 8d16ae7..af5376f 100644
--- a/kmicromail/opiemail.cpp
+++ b/kmicromail/opiemail.cpp
@@ -1,535 +1,542 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 // CHANGED 2004-08-06 Lutz Rogowski
 
 #include "koprefsdialog.h"
 #include <kapplication.h>
 #include <libkdepim/externalapphandler.h>
 #include <libkdepim/kpimglobalprefs.h>
 #ifdef  MINIKDE_KDIALOG_H
 #undef MINIKDE_KDIALOG_H
 #endif
 #include "settingsdialog.h"
 #include "opiemail.h"
 #include "editaccounts.h"
 #include "composemail.h"
 #include "mailistviewitem.h"
 #include "viewmail.h"
 #include "selectstore.h"
 #include "selectsmtp.h"
 #include "accountitem.h"
 #include "klocale.h"
 
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qcursor.h>
 #include <qregexp.h>
+#include <qpe/global.h>
 
 #ifdef DESKTOP_VERSION
 #include <qapplication.h>
 #else
 #include <qpe/qpeapplication.h>
 #endif
 #include <libmailwrapper/smtpwrapper.h>
 #include <libmailwrapper/mailtypes.h>
 #include <libmailwrapper/abstractmail.h>
 
 //using namespace Opie::Core;
 
 OpieMail::OpieMail( QWidget *parent, const char *name )
     : MainWindow( parent, name) //, WStyle_ContextHelp )
 {
     settings = new Settings();
 
     setIcon(SmallIcon( "kmicromail" )  );
     folderView->populate( settings->getAccounts() );
   
 }
 
 OpieMail::~OpieMail()
 {
     if (settings) delete settings;
 }
 
 void OpieMail::appMessage(const QCString &msg, const QByteArray &data)
 {
     
 }
 #include <stdlib.h>
 void OpieMail::message(const QCString &msg, const QByteArray &data)
 {
     // copied from old mail2
     static int ii = 0;
     //qDebug("QCOP CALL ############################# %d ", ii);
     //QString mess ( msg  );
     //qDebug("Message = %s ",mess.latin1());
     ++ii;
     //qDebug("KM:appMessage %d *%s* %x", ii, msg.data(), this);
 
     mPendingEmail = QString::null;
     mPendingName = QString::null;
     if (msg == "writeMail(QString,QString)")
     {
         //qDebug("writeMail(QString,QString) ");
         QDataStream stream(data,IO_ReadOnly);
         stream >> mPendingName >> mPendingEmail;
         // removing the whitespaces at beginning and end is needed!
         QTimer::singleShot ( 50, this, SLOT(slotComposeMail() ) ); 
     }
     else if (msg == "newMail()")
     {
         //qDebug("slotComposeMail() ");
         // we cannot call slotComposeMail(); directly, because may be executing a QCOP call
         // and a QCOP call does not like a processevents in his execution
         // with the Qtimer we call slotComposeMail() after we reached the main event loop
         QTimer::singleShot ( 50, this, SLOT(slotComposeMail() ) ); 
         // slotComposeMail();
     }
     else if (msg == "newMail(QString)")
     {
         //qDebug(" newMail(QString)");
         QDataStream stream(data,IO_ReadOnly);
         stream >> mPendingName;
         // the format is 
         //  NAME <EMAIL>:SUBJECT
         QTimer::singleShot ( 50, this, SLOT(slotComposeMail() ) ); 
     } else {
         mPendingData = data;
         mPendingMessage = msg;
         QTimer::singleShot ( 50, this, SLOT(slotExtAppHandler() ) ); 
     }
 
     //qDebug("END OpieMail::message ");
 }
 void OpieMail::slotExtAppHandler()
 {
     ExternalAppHandler::instance()->appMessage ( mPendingMessage, mPendingData );
 }
 void OpieMail::slotwriteMail2(const QString& namemail )
 {
     //qDebug("OpieMail::slotwriteMail2 ");
     //qApp->processEvents();
      ComposeMail compose( settings, this, 0, true );
     if ( !namemail.isEmpty() ) {
         QString to = namemail;
         if ( namemail.find( " <") > 1 ) {
             to = "\"" +to.replace( QRegExp( " <"), "\" <") ;
         } else 
         if ( namemail.find( "<") > 1 ) {
             to = "\"" +to.replace( QRegExp( "<"), "\" <") ;
         }
         int sub = to.find( ">:");
         if ( sub > 0 ) {
             compose.setTo( to.left(sub+1)  );
             compose.setSubject( to.mid(sub+2) );
         } else
             compose.setTo( to );
      }
     compose.slotAdjustColumns();
 #ifndef DESKTOP_VERSION
     compose.showMaximized();
 #endif
     compose.exec();
     raise();
     //qDebug("retttich ");
 }
 void OpieMail::slotwriteMail(const QString&name,const QString&email)
 {
     // qDebug("OpieMail::slotwriteMail ");
     ComposeMail compose( settings, this, 0, true );
     if (!email.isEmpty())
     {
         if (!name.isEmpty())
         {
             compose.setTo("\"" + name + "\"" + " " + "<"+ email + ">");
         }
         else
         {
             compose.setTo(email);
         }
     }
     compose.slotAdjustColumns();
 #ifndef DESKTOP_VERSION
     compose.showMaximized();
 #endif
     compose.exec();
     raise();
 }
 
 void OpieMail::slotComposeMail()
 {
     if ( mPendingEmail == QString::null && mPendingName == QString::null)
         slotwriteMail2( QString () );
     else {
         if ( mPendingEmail == QString::null )
             slotwriteMail2( mPendingName );
         else
             slotwriteMail( mPendingName, mPendingEmail );   
     }
     //slotwriteMail(0l,0l);
 }
 
 void OpieMail::slotSendQueued()
 {
     SMTPaccount *smtp = 0;
 
     QList<Account> list = settings->getAccounts();
     QList<SMTPaccount> smtpList;
     smtpList.setAutoDelete(false);
     Account *it;
     for ( it = list.first(); it; it = list.next() )
     {
         if ( it->getType() == MAILLIB::A_SMTP )
         {
             smtp = static_cast<SMTPaccount *>(it);
             smtpList.append(smtp);
         }
     }
     if (smtpList.count()==0)
     {
         QMessageBox::information(0,i18n("Info"),i18n("Define a smtp account first!\n"));
         return;
     }
+    if ( QMessageBox::warning(this, i18n("Sending all mails"), i18n("Do you really want to send\nall queued mails?" )  , QMessageBox::Yes, QMessageBox::No ) == QMessageBox::No )
+        return;
     if (smtpList.count()==1)
     {
         smtp = smtpList.at(0);
     }
     else
     {
         smtp = 0;
         selectsmtp selsmtp;
         selsmtp.setSelectionlist(&smtpList);
 #ifndef DESKTOP_VERSION
         selsmtp.showMaximized();
 #endif
         if (  selsmtp.exec() == QDialog::Accepted )
         {
             smtp = selsmtp.selected_smtp();
         }
     }
     if (smtp)
     {
+     
+        Global::statusMessage("Sending mails...!");
         SMTPwrapper * wrap = new SMTPwrapper(smtp);
         if ( wrap->flushOutbox() )
         {
-            QMessageBox::information(0,i18n("Info"),i18n("Mail queue flushed"));
-        }
+            Global::statusMessage("Mails sent!");
+        } 
         delete wrap;
     }
+    // pending refresh list view, if outgoing is displayed
 }
 
 void OpieMail::slotSearchMails()
 {
     qDebug("OpieMail::slotSearchMails():not implemented ");
 }
 
 void OpieMail::slotEditSettings()
 {
 
     KOPrefsDialog settingsDialog( this,  "koprefs", true );
 #ifndef DESKTOP_VERSION
     settingsDialog.showMaximized();
 #endif
     settingsDialog.exec();
 
     //    KApplication::execDialog(settingsDialog);
 }
 
 void OpieMail::slotEditAccounts()
 {
     EditAccounts eaDialog( settings, this, 0, true );
     eaDialog.slotAdjustColumns();
 #ifndef DESKTOP_VERSION
     eaDialog.showMaximized();
 #endif
     eaDialog.exec();
     if ( settings ) delete settings;
     settings = new Settings();
 
     folderView->populate( settings->getAccounts() );
 }
 void OpieMail::replyMail()
 {
 
     QListViewItem*item = mailView->currentItem();
     if (!item) return;
     RecMailP mail = ((MailListViewItem*)item)->data();
     RecBodyP body = folderView->fetchBody(mail);
 
     QString rtext;
     rtext += QString("* %1 wrote on %2:\n")        // no i18n on purpose
         .arg(  QString::fromUtf8( mail->getFrom().latin1()))
              .arg( QString::fromUtf8( mail->getDate().latin1() ));
 
     QString text = QString::fromUtf8( body->Bodytext().latin1() );
     QStringList lines = QStringList::split(QRegExp("\\n"), text);
     QStringList::Iterator it;
     for (it = lines.begin(); it != lines.end(); it++)
     {
         rtext += "> " + *it + "\n";
     }
     rtext += "\n";
 
     QString prefix;
     if ( mail->getSubject().find(QRegExp("^Re: .*$")) != -1) prefix = "";
     else prefix = "Re: ";                // no i18n on purpose
 
     Settings *settings = new Settings();
     ComposeMail composer( settings ,this, 0, true);
     if (mail->Replyto().isEmpty()) {
         composer.setTo( QString::fromUtf8( mail->getFrom().latin1()));
     } else {
         composer.setTo( QString::fromUtf8(mail->Replyto().latin1()));
     }
     composer.setSubject( prefix + QString::fromUtf8( mail->getSubject().latin1() ) );
     composer.setMessage( rtext );
     composer.setInReplyTo( QString::fromUtf8(mail->Msgid().latin1()));
 
     if ( QDialog::Accepted == KApplication::execDialog( &composer ) )
     {
         mail->Wrapper()->answeredMail(mail);
     }
     delete settings;
 
 }
 void OpieMail::displayMail()
 {
     QListViewItem*item = mailView->currentItem();
     if (!item) return;
     RecMailP mail = ((MailListViewItem*)item)->data();
     RecBodyP body = folderView->fetchBody(mail);
     ViewMail readMail( this,"", Qt::WType_Modal   );
     readMail.setBody( body );
     readMail.setMail( mail );
 #ifndef DESKTOP_VERSION
     readMail.showMaximized();
 #else
     readMail.resize( 640, 480);
 #endif
     readMail.exec();
 
     if (  readMail.deleted )
     {
         folderView->refreshCurrent();
     }
     else
     {
         ( (MailListViewItem*)item )->setPixmap( 0, QPixmap() );
     }
 }
 void OpieMail::slotGetAllMail()
 {
     QListViewItem * item = folderView->firstChild();
     while ( item ){
         ((AccountViewItem *)item)->contextMenuSelected( 101 );
         item = item->nextSibling ();
     }
 }
 void OpieMail::slotGetMail()
 {
     QListViewItem * item = folderView->currentItem();
     if ( ! item ) return;
     ((AccountViewItem *)item)->contextMenuSelected( 101 );
 }
 void OpieMail::slotDeleteMail()
 {
     if (!mailView->currentItem()) return;
     RecMailP mail = ((MailListViewItem*)mailView->currentItem() )->data();
     if ( QMessageBox::warning(this, i18n("Delete Mail"), QString( i18n("<p>Do you really want to delete this mail? <br><br>" ) + mail->getFrom() + " - " + mail->getSubject() ) , QMessageBox::Yes, QMessageBox::No ) == QMessageBox::Yes )
     {
         mail->Wrapper()->deleteMail( mail );
         folderView->refreshCurrent();
     }
 }
 void OpieMail::slotDeleteAllMail()
 {
 
     QValueList<RecMailP> t;
     if ( QMessageBox::warning(this, i18n("Delete All Mails"), i18n("Do you really want to delete\nall selected mails?" )  , QMessageBox::Yes, QMessageBox::No ) == QMessageBox::Yes )
         {
             MailListViewItem* item = (MailListViewItem*)mailView->firstChild ();
             while ( item ) {
                 if ( item->isSelected() ) {
                     t.append( item->data() );
                 }
                 item = (MailListViewItem*)item->nextSibling();
             }
         }
     else
         return;
     if ( t.count() == 0 )
         return;
     RecMailP mail = t.first();
     mail->Wrapper()->deleteMailList(t);
     folderView->refreshCurrent();
 
 
 }
 void OpieMail::clearSelection()
 {
     mailView->clearSelection();
   
 }
 
 void OpieMail::mailHold(int button, QListViewItem *item,const QPoint&,int  )
 {
     if (!mailView->currentItem()) return;
     MAILLIB::ATYPE mailtype = ((MailListViewItem*)mailView->currentItem() )->wrapperType();
     /* just the RIGHT button - or hold on pda */
     if (button!=2) {return;}
     if (!item) return;
     QPopupMenu *m = new QPopupMenu(0);
     if (m)
     {
         if (mailtype==MAILLIB::A_NNTP) {
             m->insertItem(i18n("Read this posting"),this,SLOT(displayMail()));
             m->insertItem(i18n("Copy this posting"),this,SLOT(slotMoveCopyMail()));
             m->insertSeparator();
             m->insertItem(i18n("Copy all selected postings"),this,SLOT(slotMoveCopyAllMail()));
             m->insertItem(i18n("Clear selection"),this,SLOT(clearSelection()));
         } else {
             if (folderView->currentisDraft()) {
                 m->insertItem(i18n("Edit this mail"),this,SLOT(reEditMail()));
             }
             m->insertItem(i18n("Reply to this mail"),this,SLOT(replyMail()));
             m->insertSeparator();
             m->insertItem(i18n("Read this mail"),this,SLOT(displayMail()));
             m->insertItem(i18n("Move/Copy this mail"),this,SLOT(slotMoveCopyMail()));
             m->insertItem(i18n("Delete this mail"),this,SLOT(slotDeleteMail()));
             m->insertSeparator();
             m->insertItem(i18n("Move/Copy all selected mail"),this,SLOT(slotMoveCopyAllMail()));
             m->insertItem(i18n("Delete all selected mails"),this,SLOT(slotDeleteAllMail()));
             m->insertItem(i18n("Clear selection"),this,SLOT(clearSelection()));
         }
         m->setFocus();
         m->exec( QPoint( QCursor::pos().x(), QCursor::pos().y()) );
         delete m;
     }
 }
 
 void OpieMail::slotShowFolders( bool show )
 {
     if ( show && folderView->isHidden() )
     {
         folderView->show();
     }
     else if ( !show && !folderView->isHidden() )
     {
         folderView->hide();
     }
 }
 
 void OpieMail::refreshMailView(const QValueList<RecMailP>&list)
 {
     MailListViewItem*item = 0;
     mailView->clear();
 
     QValueList<RecMailP>::ConstIterator it;
     for (it = list.begin(); it != list.end();++it)
     {
         item = new MailListViewItem(mailView,item);
         item->storeData((*it));
         item->showEntry();
     }
+    mailView->setSorting ( 4, false );
 }
 
 void OpieMail::mailLeftClicked( QListViewItem *item )
 {
     mailView->clearSelection();
     /* just LEFT button - or tap with stylus on pda */
     //if (button!=1) return;
     if (!item) return;
     if (folderView->currentisDraft()) {
         reEditMail();
     } else {
         displayMail();
     }
 }
 
 void OpieMail::slotMoveCopyMail()
 {
     if (!mailView->currentItem()) return;
     RecMailP mail = ((MailListViewItem*)mailView->currentItem() )->data();
     AbstractMail*targetMail = 0;
     QString targetFolder = "";
     Selectstore sels;
     folderView->setupFolderselect(&sels);
     if (!sels.exec()) return;
     targetMail = sels.currentMail();
     targetFolder = sels.currentFolder();
     if ( (mail->Wrapper()==targetMail && mail->getMbox()==targetFolder) ||
             targetFolder.isEmpty())
     {
         return;
     }
     if (sels.newFolder() && !targetMail->createMbox(targetFolder))
     {
         QMessageBox::critical(0,i18n("Error creating new Folder"),
                               i18n("<center>Error while creating<br>new folder - breaking.</center>"));
         return;
     }
     sels.hide();
     qApp->processEvents();
     // qDebug("hiding sels ");
     mail->Wrapper()->mvcpMail(mail,targetFolder,targetMail,sels.moveMails());
     folderView->refreshCurrent();
 }
 
 void OpieMail::slotMoveCopyAllMail()
 {
 
     if (!mailView->currentItem()) return;
     QValueList<RecMailP> t;
     // if ( QMessageBox::warning(this, i18n("Move/Copy all selected mails"), i18n("Do you really want to copy/move\nall selected mails?" )  , QMessageBox::Yes, QMessageBox::No ) == QMessageBox::Yes )
     {
         MailListViewItem* item = (MailListViewItem*)mailView->firstChild ();
         while ( item ) {
             if ( item->isSelected() ) {
                 t.append( item->data() );
             }
             item = (MailListViewItem*)item->nextSibling();
         }
     }
     // else
     //  return;
     if ( t.count() == 0 )
         return;
     RecMailP mail = t.first();
     AbstractMail*targetMail = 0;
     QString targetFolder = "";
     Selectstore sels;
     folderView->setupFolderselect(&sels);
     if (!sels.exec()) return;
     targetMail = sels.currentMail();
     targetFolder = sels.currentFolder();
     if ( (mail->Wrapper()==targetMail && mail->getMbox()==targetFolder) ||
             targetFolder.isEmpty())
     {
         return;
     }
     if (sels.newFolder() && !targetMail->createMbox(targetFolder))
     {
         QMessageBox::critical(0,i18n("Error creating new Folder"),
                               i18n("<center>Error while creating<br>new folder - breaking.</center>"));
         return;
     }
     sels.hide();
     qApp->processEvents();
     //qDebug("hiding sels ");
     mail->Wrapper()->mvcpMailList(t,targetFolder,targetMail,sels.moveMails());
     folderView->refreshCurrent();
 }
 
 void OpieMail::reEditMail()
 {
     if (!mailView->currentItem()) return;
 
     ComposeMail compose( settings, this, 0, true );
     compose.reEditMail(((MailListViewItem*)mailView->currentItem() )->data());
     compose.slotAdjustColumns();
 #ifndef DESKTOP_VERSION
     compose.showMaximized();
 #else
     compose.resize(640,480);
 #endif
     compose.exec();
 }
diff --git a/libkdepim/kprefswidget.cpp b/libkdepim/kprefswidget.cpp
index be9ad30..f6a0b38 100644
--- a/libkdepim/kprefswidget.cpp
+++ b/libkdepim/kprefswidget.cpp
@@ -1,427 +1,428 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
 // $Id$
 
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qgroupbox.h>
 #include <qbuttongroup.h>
 #include <qlineedit.h>
 #include <qfont.h>
 #include <qslider.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qvbox.h>
 #include <qhbox.h>
 #include <qspinbox.h>
 #include <qdatetime.h>
 #include <qframe.h>
 #include <qcombobox.h>
 #include <qcheckbox.h>
 #include <qradiobutton.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 
 #include <kcolorbutton.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kfontdialog.h>
 #include <kmessagebox.h>
 #include <kcolordialog.h>
 #include <kiconloader.h>
 
 #include "kprefs.h"
 
 #include "kprefswidget.h"
 //#include "kprefsdialog.moc"
 
 KPrefsWidBool::KPrefsWidBool(const QString &text,bool *reference,
                              QWidget *parent)
 {
   mReference = reference;
 
   mCheck = new QCheckBox(text,parent);
 
   connect( mCheck, SIGNAL( toggled( bool ) ), SIGNAL( modified() ) );
 
 }
 
 void KPrefsWidBool::readConfig()
 {
   mCheck->setChecked(*mReference);
 }
 
 void KPrefsWidBool::writeConfig()
 {
   *mReference = mCheck->isChecked();
 }
 
 QCheckBox *KPrefsWidBool::checkBox()
 {
   return mCheck;
 }
 
 
 KPrefsWidColor::KPrefsWidColor(const QString &text,QColor *reference,
                                QWidget *parent)
 {
   mReference = reference;
 
   mButton = new KColorButton(parent);
   mLabel = new QLabel(mButton, text, parent);
   mButton->setColor( *mReference );
   mButton->setColor( Qt::red );
 
   connect( mButton, SIGNAL( changed(const QColor &)), SIGNAL( modified() ) );
 
 }
 
 KPrefsWidColor::~KPrefsWidColor()
 {
 //  kdDebug(5300) << "KPrefsWidColor::~KPrefsWidColor()" << endl;
 }
 
 void KPrefsWidColor::readConfig()
 {
   mButton->setColor(*mReference);
 }
 
 void KPrefsWidColor::writeConfig()
 {
   *mReference = mButton->color();
 }
 
 QLabel *KPrefsWidColor::label()
 {
   return mLabel;
 }
 
 KColorButton *KPrefsWidColor::button()
 {
   return mButton;
 }
 
 KPrefsWidFont::KPrefsWidFont(const QString &sampleText,const QString &labelText,
                              QFont *reference,QWidget *parent)
 {
   mReference = reference;
 
   mLabel = new QLabel(labelText, parent);
 
   mPreview = new QLabel(sampleText,parent);
   mPreview->setFrameStyle(QFrame::Panel|QFrame::Sunken);
 
   mButton = new QPushButton(i18n("Choose..."), parent);
   connect(mButton,SIGNAL(clicked()),SLOT(selectFont())); 
   mPreview->setMaximumHeight( QApplication::desktop()->height() / 12 );
   mPreview->setMaximumWidth( (QApplication::desktop()->width() / 2)-10 );
 }
 
 KPrefsWidFont::~KPrefsWidFont()
 {
 }
 
 void KPrefsWidFont::readConfig()
 {
   mPreview->setFont(*mReference);
 }
 
 void KPrefsWidFont::writeConfig()
 {
   *mReference = mPreview->font();
 }
 
 QLabel *KPrefsWidFont::label()
 {
   return mLabel;
 }
 
 QLabel *KPrefsWidFont::preview()
 {
   return mPreview;
 }
 
 QPushButton *KPrefsWidFont::button()
 {
   return mButton;
 }
 
 void KPrefsWidFont::selectFont()
 {
   QFont myFont(mPreview->font());
   bool ok;
   myFont = KFontDialog::getFont(myFont, ok);
   if ( ok ) {
     mPreview->setFont(myFont);
     emit modified();
   }
 }
 
 
 KPrefsWidTime::KPrefsWidTime(const QString &text,int *reference,
                              QWidget *parent)
 {
   mReference = reference;
 
   mLabel = new QLabel(text,parent);
   mSpin = new QSpinBox(0,23,1,parent);
   mSpin->setSuffix(":00");
   connect( mSpin, SIGNAL( valueChanged(int)), SIGNAL( modified() ) );
 
 }
 
 void KPrefsWidTime::readConfig()
 {
   mSpin->setValue(*mReference);
 }
 
 void KPrefsWidTime::writeConfig()
 {
   *mReference = mSpin->value();
 }
 
 QLabel *KPrefsWidTime::label()
 {
   return mLabel;
 }
 
 QSpinBox *KPrefsWidTime::spinBox()
 {
   return mSpin;
 }
 
 
 KPrefsWidRadios::KPrefsWidRadios(const QString &text,int *reference,
                 QWidget *parent)
 {
   mReference = reference;
 
   mBox = new QButtonGroup(1,Qt::Horizontal,text,parent);
   connect( mBox, SIGNAL( clicked(int)), SIGNAL( modified() ) );
 }
 
 KPrefsWidRadios::~KPrefsWidRadios()
 {
 }
 
 void KPrefsWidRadios::addRadio(const QString &text)
 {
   new QRadioButton(text,mBox);
 }
 
 QButtonGroup *KPrefsWidRadios::groupBox()
 {
   return mBox;
 }
 
 void KPrefsWidRadios::readConfig()
 {
   mBox->setButton(*mReference);
 }
 
 void KPrefsWidRadios::writeConfig()
 {
   *mReference = mBox->id(mBox->selected());
 }
 
 
 KPrefsWidString::KPrefsWidString(const QString &text,QString *reference,
                                  QWidget *parent, QLineEdit::EchoMode echomode)
 {
   mReference = reference;
   
   mLabel = new QLabel(text,parent);
   mEdit = new QLineEdit(parent);
   mEdit->setEchoMode( echomode );
   connect( mEdit, SIGNAL( textChanged(const QString&) ), SIGNAL( modified() ) );
 
 }
 
 KPrefsWidString::~KPrefsWidString()
 {
 }
 
 void KPrefsWidString::readConfig()
 {
   mEdit->setText(*mReference);
 }
 
 void KPrefsWidString::writeConfig()
 {
   *mReference = mEdit->text();
 }
 
 QLabel *KPrefsWidString::label()
 {
   return mLabel;
 }
 
 QLineEdit *KPrefsWidString::lineEdit()
 {
   return mEdit;
 }
 
 
 KPrefsWidget::KPrefsWidget(KPrefs *prefs,QWidget *parent,const char *name) :
   QWidget(parent, name )
 {
   mPrefs = prefs;
+  mPrefsWids.setAutoDelete( true );
 }
 
 KPrefsWidget::~KPrefsWidget()
 {
 }
 
 void KPrefsWidget::addWid(KPrefsWid *wid)
 {
   mPrefsWids.append(wid);
   connect( wid, SIGNAL( modified() ), this, SLOT( modified() ) );
 
 }
 
 KPrefsWidBool *KPrefsWidget::addWidBool(const QString &text,bool *reference,QWidget *parent)
 {
   KPrefsWidBool *w = new KPrefsWidBool(text,reference,parent);
   addWid(w);
   return w;
 }
 
 KPrefsWidTime *KPrefsWidget::addWidTime(const QString &text,int *reference,QWidget *parent)
 {
   KPrefsWidTime *w = new KPrefsWidTime(text,reference,parent);
   addWid(w);
   return w;
 }
 
 KPrefsWidColor *KPrefsWidget::addWidColor(const QString &text,QColor *reference,QWidget *parent)
 {
   KPrefsWidColor *w = new KPrefsWidColor(text,reference,parent);
   addWid(w);
   return w;
 }
 
 KPrefsWidRadios *KPrefsWidget::addWidRadios(const QString &text,int *reference,QWidget *parent)
 {
   KPrefsWidRadios *w = new KPrefsWidRadios(text,reference,parent);
   addWid(w);
   return w;
 }
 
 KPrefsWidString *KPrefsWidget::addWidString(const QString &text,QString *reference,QWidget *parent)
 {
   KPrefsWidString *w = new KPrefsWidString(text,reference,parent);
   addWid(w);
   return w;
 }
 
 KPrefsWidString *KPrefsWidget::addWidPassword(const QString &text,QString *reference,QWidget *parent)
 {
   KPrefsWidString *w = new KPrefsWidString(text,reference,parent,QLineEdit::Password);
   addWid(w);
   return w;
 }
 
 KPrefsWidFont *KPrefsWidget::addWidFont(const QString &sampleText,const QString &buttonText,
                                         QFont *reference,QWidget *parent)
 {
   KPrefsWidFont *w = new KPrefsWidFont(sampleText,buttonText,reference,parent);
   addWid(w);
   return w;
 }
 
 void KPrefsWidget::setDefaults()
 {
   mPrefs->setDefaults();
   
   readConfig();
 }
 
 void KPrefsWidget::readConfig()
 {
 //  kdDebug(5300) << "KPrefsDialog::readConfig()" << endl;
 
   KPrefsWid *wid;
   for(wid = mPrefsWids.first();wid;wid=mPrefsWids.next()) {
     wid->readConfig();
   }
 
   usrReadConfig();
 
   emit changed( false );
 
 }
 
 void KPrefsWidget::writeConfig()
 {
 //  kdDebug(5300) << "KPrefsDialog::writeConfig()" << endl;
 
   KPrefsWid *wid;
   for(wid = mPrefsWids.first();wid;wid=mPrefsWids.next()) {
     wid->writeConfig();
   }
 
   usrWriteConfig();
 
 //  kdDebug(5300) << "KPrefsDialog::writeConfig() now writing..." << endl;
   
   mPrefs->writeConfig();
 
   emit changed( false );
 
 //  kdDebug(5300) << "KPrefsDialog::writeConfig() done" << endl;
 }
 
 /*US
 void KPrefsWidget::slotApply()
 {
   writeConfig();
   emit configChanged();
 }
 
 void KPrefsDialog::slotOk()
 {
   slotApply();
   QDialog::accept();
 }
 void KPrefsDialog::accept()
 {
   slotOk();
 }
 
 void KPrefsDialog::slotDefault()
 {
   if (KMessageBox::warningContinueCancel(this,
       i18n("You are about to set all\npreferences to default values.\nAll "
       "custom modifications will be lost."),i18n("Setting Default Preferences"),
       i18n("Continue"))
     == KMessageBox::Continue) setDefaults(); 
 }
 */
 
 void KPrefsWidget::modified()
 {
   emit changed( true );
 }