9 files changed, 90 insertions, 29 deletions

diff --git a/kmicromail/libmailwrapper/generatemail.h b/kmicromail/libmailwrapper/generatemail.h
index a767b61..b9f8285 100644
--- a/kmicromail/libmailwrapper/generatemail.h
+++ b/kmicromail/libmailwrapper/generatemail.h
@@ -1,46 +1,47 @@
 #ifndef __GENERATE_MAIL_H
 #define __GENERATE_MAIL_H
 
-#include <qpe/applnk.h>
+//#include <qpe/applnk.h>
 
 #include <qobject.h>
 #include <libetpan/clist.h>
+#include "mailwrapper.h"
 
 #include <opie2/osmartpointer.h>
 
 class Mail;
 class RecMail;
-class Attachment;
+
 struct mailimf_fields;
 struct mailimf_field;
 struct mailimf_mailbox;
 struct mailmime;
 struct mailimf_address_list;
 class progressMailSend;
 struct mailsmtp;
 
 class Generatemail : public QObject
 {
     Q_OBJECT
 public:
     Generatemail();
     virtual ~Generatemail();
 
 protected:
     static void addRcpts( clist *list, mailimf_address_list *addr_list );
     static char *getFrom( mailmime *mail );
     static char *getFrom( mailimf_field *ffrom);
     static mailimf_field *getField( mailimf_fields *fields, int type );
     mailimf_address_list *parseAddresses(const QString&addr );
     void addFileParts( mailmime *message,const QList<Attachment>&files );
     mailmime *buildFilePart(const QString&filename,const QString&mimetype,const QString&content);
     mailmime *buildTxtPart(const QString&str );
     mailimf_mailbox *newMailbox(const QString&name,const QString&mail );
     mailimf_fields *createImfFields(const Opie::Core::OSmartPointer<Mail> &mail );
     mailmime *createMimeMail(const Opie::Core::OSmartPointer<Mail>&mail );
     clist *createRcptList( mailimf_fields *fields );
 
     static const char* USER_AGENT;
 };
 
 #endif
diff --git a/kmicromail/libmailwrapper/libmailwrapper.pro b/kmicromail/libmailwrapper/libmailwrapper.pro
new file mode 100644
index 0000000..2b005d8
--- a/dev/null
+++ b/kmicromail/libmailwrapper/libmailwrapper.pro
@@ -0,0 +1,64 @@
+TEMPLATE        = lib
+CONFIG        += qt warn_on
+
+HEADERS         = mailwrapper.h \
+               imapwrapper.h \
+               mailtypes.h \
+               pop3wrapper.h \
+               abstractmail.h  \
+               smtpwrapper.h \
+               genericwrapper.h \
+               mboxwrapper.h \
+               settings.h \
+               logindialog.h \
+               sendmailprogress.h \
+               statusmail.h \
+               mhwrapper.h \
+               nntpwrapper.h \
+               generatemail.h \
+               storemail.h \
+               ../qpe/global.h
+
+SOURCES         = imapwrapper.cpp \
+               mailwrapper.cpp \
+               mailtypes.cpp \
+               pop3wrapper.cpp \
+               abstractmail.cpp \
+               smtpwrapper.cpp \
+               genericwrapper.cpp \
+               mboxwrapper.cpp \
+               settings.cpp \
+               logindialog.cpp \
+               sendmailprogress.cpp \
+               statusmail.cpp \
+               mhwrapper.cpp \
+              nntpwrapper.cpp \
+              generatemail.cpp \
+              storemail.cpp \
+               ../qpe/global.cpp
+
+INTERFACES     = logindialogui.ui \
+              sendmailprogressui.ui
+
+INCLUDEPATH +=  .. ../../microkde ../../microkde/kdecore ../libetpan/include 
+LIBS        +=   -lssl -lcrypto
+
+#-lqpe -letpan
+
+DESTDIR      = ../../bin
+TARGET       = micromailwrapper
+
+DEFINES +=  DESKTOP_VERSION
+unix : {
+OBJECTS_DIR = obj/unix
+MOC_DIR = moc/unix
+}
+win32: {
+DEFINES += _WIN32_  
+LIBS += mfc71u.lib
+QMAKE_LINK += /NODEFAULTLIB:LIBC
+#QMAKE_LINK += /NODEFAULTLIB:MSVCRT
+#QMAKE_LINK += /NODEFAULTLIB:uafxcw.lib
+OBJECTS_DIR = obj/win
+MOC_DIR = moc/win
+}
diff --git a/kmicromail/libmailwrapper/mailwrapper.h b/kmicromail/libmailwrapper/mailwrapper.h
index 2ba908b..88f10da 100644
--- a/kmicromail/libmailwrapper/mailwrapper.h
+++ b/kmicromail/libmailwrapper/mailwrapper.h
@@ -1,68 +1,68 @@
 #ifndef MAILWRAPPER_H
 #define MAILWRAPPER_H
 
-#include <qpe/applnk.h>
+//#include <qpe/applnk.h>
 
 #include <qbitarray.h>
 #include <qdatetime.h>
 #include <qfileinfo.h>
 #include <kiconloader.h>
 
 #include "settings.h"
 
 #include <opie2/osmartpointer.h>
 /*
 class Attachment
 {
 public:
     Attachment( DocLnk lnk );
     virtual ~Attachment(){}
     const QString getFileName()const{ return doc.file(); }
     const QString getName()const{ return doc.name(); }
     const QString getMimeType()const{ return doc.type(); }
     const QPixmap getPixmap()const{ return doc.pixmap(); }
     const int getSize()const { return size; }
     DocLnk  getDocLnk() { return doc; }
 
 protected:
     DocLnk doc;
     int size;
 
 };
 */
 
 class Attachment
 {
 public:
     Attachment( QString lnk );
     virtual ~Attachment(){}
     const QString getFileName()const{ return  doc; }
     const QString getName()const{ return QFileInfo( doc ).baseName (); }
     const QString getMimeType()const{ return QFileInfo( doc ).extension(false); }
     const QPixmap getPixmap()const{ return mPix; }
     const int getSize()const { return size; }
     QString  getDocLnk() { return doc; }
 
 protected:
     QPixmap mPix;
     QString doc;
     int size;
 
 };
 
 class Mail:public Opie::Core::ORefCount
 {
 public:
     Mail();
     /* Possible that this destructor must not be declared virtual
      * 'cause it seems that it will never have some child classes.
      * in this case this object will not get a virtual table -> memory and
      * speed will be a little bit better?
      */
     virtual ~Mail(){}
     void addAttachment( Attachment *att ) { attList.append( att ); }
     const QList<Attachment>& getAttachments()const { return attList; }
     void removeAttachment( Attachment *att ) { attList.remove( att ); }
     const QString&getName()const { return name; }
     void setName( QString s ) { name = s; }
     const QString&getMail()const{ return mail; }
diff --git a/kmicromail/libmailwrapper/mhwrapper.cpp b/kmicromail/libmailwrapper/mhwrapper.cpp
index f4133c0..de6d220 100644
--- a/kmicromail/libmailwrapper/mhwrapper.cpp
+++ b/kmicromail/libmailwrapper/mhwrapper.cpp
@@ -1,76 +1,76 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 #include "mhwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <stdlib.h>
 #include <qpe/global.h>
-#include <oprocess.h>
 #include <klocale.h>
-//#include <opie2/odebug.h>
+#include <kglobal.h>
+//#include <opie2/odebug.h> 
 
 using namespace Opie::Core;
 MHwrapper::MHwrapper(const QString & mbox_dir,const QString&mbox_name)
     : Genericwrapper(),MHPath(mbox_dir),MHName(mbox_name)
 {
     if (MHPath.length()>0) {
         if (MHPath[MHPath.length()-1]=='/') {
             MHPath=MHPath.left(MHPath.length()-1);
         }
         //odebug << MHPath << oendl; 
         QDir dir(MHPath);
         if (!dir.exists()) {
             dir.mkdir(MHPath);
         }
         init_storage();
     }
 }
 
 void MHwrapper::init_storage()
 {
     int r;
     QString pre = MHPath;
     if (!m_storage) {
         m_storage = mailstorage_new(NULL);
         r = mh_mailstorage_init(m_storage,(char*)pre.latin1(),0,0,0);
         if (r != MAIL_NO_ERROR) {
             qDebug(" error init storage  ");
             mailstorage_free(m_storage);
             m_storage = 0;
             return;
         }
     }
     r = mailstorage_connect(m_storage);
     if (r!=MAIL_NO_ERROR) {
         qDebug("error connecting storage ");
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 void MHwrapper::clean_storage()
 {
     if (m_storage) {
         mailstorage_disconnect(m_storage);
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 MHwrapper::~MHwrapper()
 {
     clean_storage();
 }
 
 void MHwrapper::listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb  )
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     QString f = buildPath(mailbox);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("listMessages: error selecting folder! ");
@@ -254,161 +254,155 @@ void MHwrapper::deleteMails(const QString & mailbox,const QValueList<RecMailP> &
     if (r!=MAIL_NO_ERROR) {
         qDebug("deleteMails: error selecting folder! ");
         return;
     }
     QValueList<RecMailP>::ConstIterator it;
     for (it=target.begin(); it!=target.end();++it) {
         r = mailsession_remove_message(m_storage->sto_session,(*it)->getNumber());
         if (r != MAIL_NO_ERROR) {
             qDebug("error deleting mail ");
             break;
         }
     }
 }
 
 int MHwrapper::deleteAllMail(const FolderP&tfolder)
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     int res = 1;
     if (!tfolder) return 0;
     int r = mailsession_select_folder(m_storage->sto_session,(char*)tfolder->getName().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder! ");
         return 0;
     }
     mailmessage_list*l=0;
     r = mailsession_get_messages_list(m_storage->sto_session,&l);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error message list ");
         res = 0;
     }
     unsigned j = 0;
     for(unsigned int i = 0 ; l!= 0 && res==1 && i < carray_count(l->msg_tab) ; ++i) {
         mailmessage * msg;
         msg = (mailmessage*)carray_get(l->msg_tab, i);
         j = msg->msg_index;
         r = mailsession_remove_message(m_storage->sto_session,j);
         if (r != MAIL_NO_ERROR) {
             Global::statusMessage(i18n("Error deleting mail %1").arg(i+1));
             res = 0;
             break;
         }
     }
     if (l) mailmessage_list_free(l);
     return res;
 }
 
 int MHwrapper::deleteMbox(const FolderP&tfolder)
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     if (!tfolder) return 0;
     if (tfolder->getName()=="/" || tfolder->getName().isEmpty()) return 0;
 
     int r = mailsession_delete_folder(m_storage->sto_session,(char*)tfolder->getName().latin1());
 
     if (r != MAIL_NO_ERROR) {
         qDebug("error deleting mail box ");
         return 0;
     }
+    QString delDir = locateLocal( "apps", "kopiemail")+ "localmail";
+    qDebug("*****************\ndel %s     %s ", delDir.latin1(),tfolder->getName().latin1() );
+#if 0
     QString cmd = "rm -rf "+tfolder->getName();
     QStringList command;
     command << "/bin/sh";
     command << "-c";
     command << cmd.latin1();
     OProcess *process = new OProcess();
 
+    /*
     connect(process, SIGNAL(processExited(Opie::Core::OProcess*)),
             this, SLOT( processEnded(Opie::Core::OProcess*)));
     connect(process, SIGNAL( receivedStderr(Opie::Core::OProcess*,char*,int)),
             this, SLOT( oprocessStderr(Opie::Core::OProcess*,char*,int)));
-
+    */
     *process << command;
     removeMboxfailed = false;
     if(!process->start(OProcess::Block, OProcess::All) ) {
         qDebug("could not start process ");
         return 0;
     }
+#endif
     qDebug("mail box deleted ");
     return 1;
 }
 
-void MHwrapper::processEnded(OProcess *p)
-{
-    if (p) delete p;
-}
-
-void MHwrapper::oprocessStderr(OProcess*, char *buffer, int )
-{
-    QString lineStr = buffer;
-    QMessageBox::warning( 0, i18n("Error"), lineStr ,i18n("Ok") );
-    removeMboxfailed = true;
-}
 
 void MHwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     QString f = buildPath(mailbox);
     int r = mailsession_status_folder(m_storage->sto_session,(char*)f.latin1(),&target_stat.message_count,
             &target_stat.message_recent,&target_stat.message_unseen);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error retrieving status"));
     }
 }
 
 MAILLIB::ATYPE MHwrapper::getType()const
 {
     return MAILLIB::A_MH;
 }
 
 const QString&MHwrapper::getName()const
 {
     return MHName;
 }
 void MHwrapper::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     if (targetWrapper != this) {
         qDebug("Using generic ");
         Genericwrapper::mvcpMail(mail,targetFolder,targetWrapper,moveit);
         return;
     }
     qDebug("Using internal routines for move/copy ");
     QString tf = buildPath(targetFolder);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r != MAIL_NO_ERROR) {
         qDebug("Error selecting source mailbox ");
         return;
     }
     if (moveit) {
         r = mailsession_move_message(m_storage->sto_session,mail->getNumber(),(char*)tf.latin1());
     } else {
         r = mailsession_copy_message(m_storage->sto_session,mail->getNumber(),(char*)tf.latin1());
     }
     if (r != MAIL_NO_ERROR) {
         qDebug("Error copy/moving mail internal ");
     }
 }
 
 void MHwrapper::mvcpAllMails(const FolderP&fromFolder,
     const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     if (targetWrapper != this) {
         qDebug("Using generic ");
diff --git a/kmicromail/libmailwrapper/mhwrapper.h b/kmicromail/libmailwrapper/mhwrapper.h
index d1b7d1f..87f8ca1 100644
--- a/kmicromail/libmailwrapper/mhwrapper.h
+++ b/kmicromail/libmailwrapper/mhwrapper.h
@@ -1,62 +1,58 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 #ifndef __MH_WRAPPER_H
 #define __MH_WRAPPER_H
 
 #include "maildefines.h"
 
 #include "genericwrapper.h"
 #include <qstring.h>
 
 class encodedString;
 struct mailmbox_folder;
-namespace Opie {namespace Core {class OProcess;}}
-
 class MHwrapper : public Genericwrapper
 {
     Q_OBJECT
 public:
     MHwrapper(const QString & dir,const QString&name);
     virtual ~MHwrapper();
 
     virtual void listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb = 0 );
     virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
     virtual void mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
     virtual void mvcpAllMails(const Opie::Core::OSmartPointer<Folder>&fromFolder,
         const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
 
     virtual int createMbox(const QString&folder,const Opie::Core::OSmartPointer<Folder>&f=0,
         const QString&d="",bool s=false);
     virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&);
 
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
 
     virtual RecBodyP fetchBody( const RecMailP &mail );
     static void mbox_progress( size_t current, size_t maximum );
 
     virtual encodedString* fetchRawBody(const RecMailP&mail);
     virtual void deleteMails(const QString & FolderName,const QValueList<Opie::Core::OSmartPointer<RecMail> > &target);
     virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&);
     virtual MAILLIB::ATYPE getType()const;
     virtual const QString&getName()const;
     virtual Account* getAccount() { return 0; };
 
 public slots:
-    /* for deleting maildirs we are using a system call */
-    virtual void oprocessStderr(Opie::Core::OProcess*, char *buffer, int );
-    virtual void processEnded(Opie::Core::OProcess *);
+   
 protected:
     QString buildPath(const QString&p);
     QString MHPath;
     QString MHName;
 
     void init_storage();
     void clean_storage();
 
     bool removeMboxfailed;
 };
 
 #endif
diff --git a/kmicromail/libmailwrapper/settings.h b/kmicromail/libmailwrapper/settings.h
index 61051dd..79567ef 100644
--- a/kmicromail/libmailwrapper/settings.h
+++ b/kmicromail/libmailwrapper/settings.h
@@ -1,74 +1,75 @@
 #ifndef SETTINGS_H
 #define SETTINGS_H
 
 #include "maildefines.h"
 
 /* OPIE */
 
 /* QT */
 #include <qobject.h>
 #include <qlist.h>
+#include <qstringlist.h>
 #include <qdatetime.h>
 
 class Account
 {
 
 public:
     Account();
     virtual ~Account() {}
 
     void remove();
     void setAccountName( QString name ) { accountName = name; }
     const QString&getAccountName()const{ return accountName; }
     MAILLIB::ATYPE getType()const{ return type; }
 
     void setServer(const QString&str){ server = str; }
     const QString&getServer()const{ return server; }
 
     void setLocalFolder( QString name ) { localFolder = name; }
     const QString& getLocalFolder()const{ return localFolder; }
 
     void setPort(const QString&str) { port = str; }
     const QString&getPort()const{ return port; }
 
     void setUser(const QString&str){ user = str; }
     const QString&getUser()const{ return user; }
 
     void setPassword(const QString&str) { password = str; }
     const QString&getPassword()const { return password; }
 
     void setPasswordList(const QStringList &str);
     QStringList getPasswordList();
 
     void setSSL( bool b ) { ssl = b; }
     bool getSSL() { return ssl; }
 
     void setConnectionType( int x ) { connectionType = x; }
     int ConnectionType() { return connectionType; }
 
     void setMaxMailSize( int x ) { maxMailSize = x; }
     int getMaxMailSize() { return maxMailSize; }
 
     void setOffline(bool b) {offline = b;}
     bool getOffline()const{return offline;}
 
     bool getLeaveOnServer(){ return leaveOnServer;}
     void setLeaveOnServer(bool b){ leaveOnServer = b;}
 
     virtual QString getFileName() { return accountName; }
     virtual void read() { ; }
     virtual void save() { ; }
 
 protected:
     QString accountName, server, port, user, password;
     bool ssl;
     int connectionType;
     bool offline;
     MAILLIB::ATYPE type;
     QString localFolder;
     int maxMailSize;
     QDateTime lastFetch;
     bool leaveOnServer;
 };
 
 class IMAPaccount : public Account
diff --git a/kmicromail/libmailwrapper/smtpwrapper.cpp b/kmicromail/libmailwrapper/smtpwrapper.cpp
index dee1477..eb07ef1 100644
--- a/kmicromail/libmailwrapper/smtpwrapper.cpp
+++ b/kmicromail/libmailwrapper/smtpwrapper.cpp
@@ -1,194 +1,199 @@
 #include "smtpwrapper.h"
 #include "mailwrapper.h"
 #include "abstractmail.h"
 #include "logindialog.h"
 #include "mailtypes.h"
 #include "sendmailprogress.h"
 
 //#include <opie2/odebug.h>
 //#include <qt.h>
 #include <qapplication.h>
 #include <qmessagebox.h>
 #include <stdlib.h>
-#include <qpe/config.h>
+#ifndef DESKTOP_VERSION
+//#include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
-
+#endif
 #include <libetpan/libetpan.h>
 #include <klocale.h>
+#include <kglobal.h>
+#include <kconfig.h>
 
 
 using namespace Opie::Core;
 progressMailSend*SMTPwrapper::sendProgress = 0;
 
 SMTPwrapper::SMTPwrapper(SMTPaccount * aSmtp )
     : Generatemail()
 {
     m_SmtpAccount = aSmtp;
-    Config cfg( "mail" );
+    KConfig cfg( locateLocal("config", "kopiemail" ) );
     cfg.setGroup( "Status" );
     m_queuedMail =  cfg.readNumEntry( "outgoing", 0 );
     emit queuedMails( m_queuedMail );
     connect( this, SIGNAL( queuedMails(int) ), this, SLOT( emitQCop(int) )  );
     m_smtp = 0;
 }
 
 SMTPwrapper::~SMTPwrapper()
 {
     disc_server();
 }
 
 void SMTPwrapper::emitQCop( int queued ) {
+#ifndef DESKTOP_VERSION
     QCopEnvelope env( "QPE/Pim", "outgoingMails(int)" );
     env << queued;
+#endif
 }
 
 QString SMTPwrapper::mailsmtpError( int errnum ) {
     switch ( errnum ) {
     case MAILSMTP_NO_ERROR:
         return i18n( "No error" );
     case MAILSMTP_ERROR_UNEXPECTED_CODE:
         return i18n( "Unexpected error code" );
     case MAILSMTP_ERROR_SERVICE_NOT_AVAILABLE:
         return i18n( "Service not available" );
     case MAILSMTP_ERROR_STREAM:
         return i18n( "Stream error" );
     case MAILSMTP_ERROR_HOSTNAME:
         return i18n( "gethostname() failed" );
     case MAILSMTP_ERROR_NOT_IMPLEMENTED:
         return i18n( "Not implemented" );
     case MAILSMTP_ERROR_ACTION_NOT_TAKEN:
         return i18n( "Error, action not taken" );
     case MAILSMTP_ERROR_EXCEED_STORAGE_ALLOCATION:
         return i18n( "Data exceeds storage allocation" );
     case MAILSMTP_ERROR_IN_PROCESSING:
         return i18n( "Error in processing" );
     case MAILSMTP_ERROR_STARTTLS_NOT_SUPPORTED:
         return i18n( "Starttls not supported" );
         //      case MAILSMTP_ERROR_INSUFFISANT_SYSTEM_STORAGE:
         //        return i18n( "Insufficient system storage" );
     case MAILSMTP_ERROR_MAILBOX_UNAVAILABLE:
         return i18n( "Mailbox unavailable" );
     case MAILSMTP_ERROR_MAILBOX_NAME_NOT_ALLOWED:
         return i18n( "Mailbox name not allowed" );
     case MAILSMTP_ERROR_BAD_SEQUENCE_OF_COMMAND:
         return i18n( "Bad command sequence" );
     case MAILSMTP_ERROR_USER_NOT_LOCAL:
         return i18n( "User not local" );
     case MAILSMTP_ERROR_TRANSACTION_FAILED:
         return i18n( "Transaction failed" );
     case MAILSMTP_ERROR_MEMORY:
         return i18n( "Memory error" );
     case MAILSMTP_ERROR_CONNECTION_REFUSED:
         return i18n( "Connection refused" );
     default:
         return i18n( "Unknown error code" );
     }
 }
 
 
 void SMTPwrapper::progress( size_t current, size_t maximum ) {
     if (SMTPwrapper::sendProgress) {
         SMTPwrapper::sendProgress->setSingleMail(current, maximum );
         qApp->processEvents();
     }
 }
 
 void SMTPwrapper::storeMail(const char*mail, size_t length, const QString&box) {
     if (!mail)
         return;
     QString localfolders = AbstractMail::defaultLocalfolder();
     AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     wrap->createMbox(box);
     wrap->storeMessage(mail,length,box);
     delete wrap;
 }
 
 bool SMTPwrapper::smtpSend( mailmime *mail,bool later) {
     clist *rcpts = 0;
     char *from, *data;
     size_t size;
 
     from = data = 0;
 
     mailmessage * msg = 0;
     msg = mime_message_init(mail);
     mime_message_set_tmpdir(msg,getenv( "HOME" ));
     int r = mailmessage_fetch(msg,&data,&size);
     mime_message_detach_mime(msg);
     mailmessage_free(msg);
     if (r != MAIL_NO_ERROR || !data) {
         if (data)
             free(data);
         qDebug("Error fetching mime... ");
         return false;
     }
     msg = 0;
     if (later) {
         storeMail(data,size,"Outgoing");
         if (data)
             free( data );
-        Config cfg( "mail" );
+        KConfig cfg( locateLocal("config", "kopiemail" ) );
         cfg.setGroup( "Status" );
         cfg.writeEntry( "outgoing", ++m_queuedMail );
         emit queuedMails( m_queuedMail );
         return true;
     }
     from = getFrom( mail );
     rcpts = createRcptList( mail->mm_data.mm_message.mm_fields );
     bool result = smtpSend(from,rcpts,data,size);
     if (data) {
         free(data);
     }
     if (from) {
         free(from);
     }
     if (rcpts)
         smtp_address_list_free( rcpts );
     return result;
 }
 
 void SMTPwrapper::storeFailedMail(const char*data,unsigned int size, const char*failuremessage)
 {
     if (data) {
         storeMail(data,size,"Sendfailed");
     }
     if (failuremessage) {
         QMessageBox::critical(0,i18n("Error sending mail"),
             i18n("<center>%1</center>").arg(failuremessage));
     }
 }
 
 int SMTPwrapper::start_smtp_tls()
 {
     if (!m_smtp) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int err = mailesmtp_starttls(m_smtp);
     if (err != MAILSMTP_NO_ERROR) return err;
     mailstream_low * low;
     mailstream_low * new_low;
     low = mailstream_get_low(m_smtp->stream);
     if (!low) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     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_smtp->stream, new_low);
     } else {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     return err;
 }
 
 void SMTPwrapper::connect_server()
 {
     QString server, user, pass;
     bool ssl;
     uint16_t port;
     ssl = false;
     bool try_tls = true;
     bool force_tls=false;
     QString failuretext = "";
 
     if (m_smtp || !m_SmtpAccount) {
@@ -386,76 +391,76 @@ bool SMTPwrapper::flushOutbox() {
 
     ; // odebug << "Sending the queue" << oendl; 
     if (!m_SmtpAccount) {
         ; // odebug << "No smtp account given" << oendl; 
         return false;
     }
 
     bool reset_user_value = false;
     QString localfolders = AbstractMail::defaultLocalfolder();
     AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     if (!wrap) {
         ; // odebug << "memory error" << oendl; 
         return false;
     }
     QString oldPw, oldUser;
     QValueList<RecMailP> mailsToSend;
     QValueList<RecMailP> mailsToRemove;
     QString mbox("Outgoing");
     wrap->listMessages(mbox,mailsToSend);
     if (mailsToSend.count()==0) {
         delete wrap;
         ; // odebug << "No mails to send" << oendl; 
         return false;
     }
 
     oldPw = m_SmtpAccount->getPassword();
     oldUser = m_SmtpAccount->getUser();
     if (m_SmtpAccount->getLogin() && (m_SmtpAccount->getUser().isEmpty() || m_SmtpAccount->getPassword().isEmpty()) ) {
         // get'em
         QString user,pass;
         LoginDialog login( m_SmtpAccount->getUser(), m_SmtpAccount->getPassword(), NULL, 0, true );
         login.show();
         if ( QDialog::Accepted == login.exec() ) {
             // ok
             user = login.getUser().latin1();
             pass = login.getPassword().latin1();
             reset_user_value = true;
             m_SmtpAccount->setUser(user);
             m_SmtpAccount->setPassword(pass);
         } else {
             return true;
         }
     }
 
 
     sendProgress = new progressMailSend();
     sendProgress->show();
     sendProgress->setMaxMails(mailsToSend.count());
 
     while (mailsToSend.count()>0) {
         if (sendQueuedMail(wrap, (*mailsToSend.begin()))==0) {
             QMessageBox::critical(0,i18n("Error sending mail"),
                                   i18n("Error sending queued mail - breaking"));
             returnValue = false;
             break;
         }
         mailsToRemove.append((*mailsToSend.begin()));
         mailsToSend.remove(mailsToSend.begin());
         sendProgress->setCurrentMails(mailsToRemove.count());
     }
     if (reset_user_value) {
         m_SmtpAccount->setUser(oldUser);
         m_SmtpAccount->setPassword(oldPw);
     }
-    Config cfg( "mail" );
+    KConfig cfg( locateLocal("config", "kopiemail" ) );
     cfg.setGroup( "Status" );
     m_queuedMail = 0;
     cfg.writeEntry( "outgoing", m_queuedMail );
     emit queuedMails( m_queuedMail );
     sendProgress->hide();
     delete sendProgress;
     sendProgress = 0;
     wrap->deleteMails(mbox,mailsToRemove);
     delete wrap;
     return returnValue;
 }
diff --git a/kmicromail/libmailwrapper/smtpwrapper.h b/kmicromail/libmailwrapper/smtpwrapper.h
index ec42b56..bdca000 100644
--- a/kmicromail/libmailwrapper/smtpwrapper.h
+++ b/kmicromail/libmailwrapper/smtpwrapper.h
@@ -1,64 +1,64 @@
 // -*- Mode: C++; -*-
 #ifndef SMTPwrapper_H
 #define SMTPwrapper_H
 
-#include <qpe/applnk.h>
+//#include <qpe/applnk.h>
 
 #include <qbitarray.h>
 #include <qdatetime.h>
 #include <libetpan/clist.h>
 
 #include "settings.h"
 #include "generatemail.h"
 
 #include <opie2/osmartpointer.h>
 
 class SMTPaccount;
 class AbstractMail;
 
 class SMTPwrapper : public Generatemail
 {
     Q_OBJECT
 
 public:
     SMTPwrapper(SMTPaccount * aSmtp);
     virtual ~SMTPwrapper();
     bool sendMail(const Opie::Core::OSmartPointer<Mail>& mail,bool later=false );
     bool flushOutbox();
 
     static progressMailSend*sendProgress;
     virtual Account* getAccount() { return m_SmtpAccount; };
 
 signals:
     void queuedMails( int );
 
 protected:
     mailsmtp *m_smtp;
     SMTPaccount * m_SmtpAccount;
 
     void connect_server();
     void disc_server();
     int start_smtp_tls();
 
 
     bool smtpSend( mailmime *mail,bool later);
 
     static void storeMail(const char*mail, size_t length, const QString&box);
     static QString mailsmtpError( int err );
     static void progress( size_t current, size_t maximum );
 
     int smtpSend(char*from,clist*rcpts,const char*data,size_t size);
 
     void storeMail(mailmime*mail, const QString&box);
 
     int sendQueuedMail(AbstractMail*wrap,const Opie::Core::OSmartPointer<RecMail>&which);
     void storeFailedMail(const char*data,unsigned int size, const char*failuremessage);
 
     int m_queuedMail;
 
 protected slots:
     void emitQCop( int queued );
 
 };
 
 #endif
diff --git a/kmicromail/libmailwrapper/storemail.h b/kmicromail/libmailwrapper/storemail.h
index 4433de0..e449f57 100644
--- a/kmicromail/libmailwrapper/storemail.h
+++ b/kmicromail/libmailwrapper/storemail.h
@@ -1,29 +1,29 @@
 #ifndef __STORE_MAIL_H
 #define __STORE_MAIL_H
 
-#include <qpe/applnk.h>
+//#include <qpe/applnk.h>
 
 #include "generatemail.h"
 
 class Account;
 class Mail;
 class AbstractMail;
 
 class Storemail : public Generatemail
 {
     Q_OBJECT
 public:
     Storemail(Account*aAccount,const QString&aFolder);
     Storemail(const QString&dir,const QString&aFolder);
     Storemail(const QString&aFolder);
     virtual ~Storemail();
 
     int storeMail(const Opie::Core::OSmartPointer<Mail>&mail);
 
 protected:
     Account* m_Account;
     QString m_tfolder;
     AbstractMail*wrapper;
 };
 
 #endif