download mail mostly finished

accounts can be switched "offline"

17 files changed, 415 insertions, 78 deletions

diff --git a/noncore/net/mail/accountview.cpp b/noncore/net/mail/accountview.cpp
index faa6982..eea021f 100644
--- a/noncore/net/mail/accountview.cpp
+++ b/noncore/net/mail/accountview.cpp
@@ -1,693 +1,879 @@
 #include "accountview.h"
 #include <libmailwrapper/mailtypes.h>
 #include <libmailwrapper/abstractmail.h>
 #include "defines.h"
 #include "newmaildir.h"
 #include "selectstore.h"
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 
 /**
  * POP3 Account stuff
  */
-POP3viewItem::POP3viewItem( POP3account *a, QListView *parent )
+POP3viewItem::POP3viewItem( POP3account *a, AccountView *parent )
     : AccountViewItem( parent )
 {
     account = a;
     wrapper = AbstractMail::getWrapper( account );
     setPixmap( 0, PIXMAP_POP3FOLDER );
     setText( 0, account->getAccountName() );
     setOpen( true );
 }
 
 POP3viewItem::~POP3viewItem()
 {
     delete wrapper;
 }
 
 AbstractMail *POP3viewItem::getWrapper()
 {
     return wrapper;
 }
 
 void POP3viewItem::refresh( QList<RecMail> & )
 {
+    if (account->getOffline()) return;
     QList<Folder> *folders = wrapper->listFolders();
     QListViewItem *child = firstChild();
     while ( child ) {
         QListViewItem *tmp = child;
         child = child->nextSibling();
         delete tmp;
     }
     Folder *it;
     QListViewItem*item = 0;
     for ( it = folders->first(); it; it = folders->next() ) {
         item = new POP3folderItem( it, this , item );
         item->setSelectable(it->may_select());
     }
     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     folders->setAutoDelete(false);
     delete folders;
 }
 
 RecBody POP3viewItem::fetchBody( const RecMail &mail )
 {
     qDebug( "POP3 fetchBody" );
     return wrapper->fetchBody( mail );
 }
 
+QPopupMenu * POP3viewItem::getContextMenu()
+{
+    QPopupMenu *m = new QPopupMenu(0);
+    if (m) {
+        if (!account->getOffline()) {
+            m->insertItem(QObject::tr("Disconnect",contextName),0);
+            m->insertItem(QObject::tr("Set offline",contextName),1);
+        } else {
+            m->insertItem(QObject::tr("Set online",contextName),1);
+        }
+    }
+    return m;
+}
+
+void POP3viewItem::disconnect()
+{
+    QListViewItem *child = firstChild();
+    while ( child ) {
+        QListViewItem *tmp = child;
+        child = child->nextSibling();
+        delete tmp;
+    }
+    wrapper->logout();
+}
+
+void POP3viewItem::setOnOffline()
+{
+    if (!account->getOffline()) {
+        disconnect();
+    }
+    account->setOffline(!account->getOffline());
+    account->save();
+}
+
+void POP3viewItem::contextMenuSelected(int which)
+{
+    switch (which) {
+    case 0:
+        disconnect();
+        break;
+    case 1:
+        setOnOffline();
+        break;
+    }
+}
+
 POP3folderItem::~POP3folderItem()
 {
     delete folder;
 }
 
 POP3folderItem::POP3folderItem( Folder *folderInit, POP3viewItem *parent , QListViewItem*after  )
     : AccountViewItem( parent,after )
 {
     folder = folderInit;
     pop3 = parent;
     if (folder->getDisplayName().lower()!="inbox") {
         setPixmap( 0, PIXMAP_POP3FOLDER );
     } else {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     }
     setText( 0, folder->getDisplayName() );
 }
 
 void POP3folderItem::refresh(QList<RecMail>&target)
 {
     if (folder->may_select())
         pop3->getWrapper()->listMessages( folder->getName(),target );
 }
 
 RecBody POP3folderItem::fetchBody(const RecMail&aMail)
 {
     return pop3->getWrapper()->fetchBody(aMail);
 }
 
 QPopupMenu * POP3folderItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m) {
         m->insertItem(QObject::tr("Refresh header list",contextName),0);
         m->insertItem(QObject::tr("Delete all mails",contextName),1);
-        m->insertItem(QObject::tr("Download all mails",contextName),2);
+        m->insertItem(QObject::tr("Move/Copie all mails",contextName),2);
     }
     return m;
 }
 
 void POP3folderItem::downloadMails()
 {
-    Selectstore sels;
-    sels.showMaximized();
-    sels.exec();
+    AccountView*bl = pop3->accountView();
+    if (!bl) return;
+    bl->downloadMails(folder,pop3->getWrapper());
 }
 
 void POP3folderItem::contextMenuSelected(int which)
 {
     AccountView * view = (AccountView*)listView();
     switch (which) {
     case 0:
         /* must be 'cause pop3 lists are cached */
         pop3->getWrapper()->logout();
         view->refreshCurrent();
         break;
     case 1:
         deleteAllMail(pop3->getWrapper(),folder);
         break;
     case 2:
         downloadMails();
         break;
     default:
         break;
     }
 }
 
 /**
  * IMAP Account stuff
  */
-IMAPviewItem::IMAPviewItem( IMAPaccount *a, QListView *parent )
+IMAPviewItem::IMAPviewItem( IMAPaccount *a, AccountView *parent )
     : AccountViewItem( parent )
 {
     account = a;
     wrapper = AbstractMail::getWrapper( account );
     setPixmap( 0, PIXMAP_IMAPFOLDER );
     setText( 0, account->getAccountName() );
     setOpen( true );
 }
 
 IMAPviewItem::~IMAPviewItem()
 {
     delete wrapper;
 }
 
 AbstractMail *IMAPviewItem::getWrapper()
 {
     return wrapper;
 }
 
 IMAPfolderItem*IMAPviewItem::findSubItem(const QString&path,IMAPfolderItem*start)
 {
     IMAPfolderItem*pitem,*sitem;
     if (!start) pitem = (IMAPfolderItem*)firstChild();
     else pitem = (IMAPfolderItem*)start->firstChild();
     while (pitem) {
         if (pitem->matchName(path)) {
             break;
         }
         if (pitem->childCount()>0) {
             sitem = findSubItem(path,pitem);
             if (sitem) {
                 pitem = sitem;
                 break;
             }
         }
         pitem=(IMAPfolderItem*)pitem->nextSibling();
     }
     return pitem;
 }
 
 void IMAPviewItem::refresh(QList<RecMail>&)
 {
     refreshFolders(false);
 }
 
 void IMAPviewItem::removeChilds()
 {
     QListViewItem *child = firstChild();
     while ( child ) {
         QListViewItem *tmp = child;
         child = child->nextSibling();
         delete tmp;
     }
 
 }
 
+const QStringList&IMAPviewItem::subFolders()
+{
+    return currentFolders;
+}
+
 void IMAPviewItem::refreshFolders(bool force)
 {
     if (childCount()>0 && force==false) return;
-    
-    removeChilds();
+    if (account->getOffline()) return;   
 
+    removeChilds();
+    currentFolders.clear();
     QList<Folder> *folders = wrapper->listFolders();
 
     Folder *it;
     QListViewItem*item = 0;
     QListViewItem*titem = 0;
     QString fname,del,search;
     int pos;
     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     folders->setAutoDelete(false);
 
     for ( it = folders->first(); it; it = folders->next() ) {
         if (it->getDisplayName().lower()=="inbox") {
             item = new IMAPfolderItem( it, this , item );
             folders->remove(it);
             qDebug("inbox found");
             break;
         }
     }
     for ( it = folders->first(); it; it = folders->next() ) {
         fname = it->getDisplayName();
+        currentFolders.append(it->getName());
         pos = fname.findRev(it->Separator());
         if (pos != -1) {
             fname = fname.left(pos);
         }
         IMAPfolderItem*pitem = findSubItem(fname);
         if (pitem) {
             titem = item;
             item = new IMAPfolderItem(it,pitem,pitem->firstChild(),this);
             /* setup the short name */
             item->setText(0,it->getDisplayName().right(it->getDisplayName().length()-pos-1));
             item = titem;
         } else {
             item = new IMAPfolderItem( it, this , item );
         }
     }
     delete folders;
 }
 
 QPopupMenu * IMAPviewItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m) {
-        m->insertItem(QObject::tr("Refresh folder list",contextName),0);
-        m->insertItem(QObject::tr("Create new folder",contextName),1);
-        m->insertSeparator();
-        m->insertItem(QObject::tr("Disconnect",contextName),2);
+        if (!account->getOffline()) {
+            m->insertItem(QObject::tr("Refresh folder list",contextName),0);
+            m->insertItem(QObject::tr("Create new folder",contextName),1);
+            m->insertSeparator();
+            m->insertItem(QObject::tr("Disconnect",contextName),2);
+            m->insertItem(QObject::tr("Set offline",contextName),3);
+        } else {
+            m->insertItem(QObject::tr("Set online",contextName),3);
+        }
     }
     return m;
 }
 
 void IMAPviewItem::createNewFolder()
 {
     Newmdirdlg ndirdlg;
     ndirdlg.showMaximized();
     if (ndirdlg.exec()) {
         QString ndir = ndirdlg.Newdir();
         bool makesubs = ndirdlg.subpossible();
         QString delemiter = "/";
         IMAPfolderItem*item = (IMAPfolderItem*)firstChild();
         if (item) {
             delemiter = item->Delemiter();
         }
         if (wrapper->createMbox(ndir,0,delemiter,makesubs)) {
             refreshFolders(true);
         }
     }
 }
 
 void IMAPviewItem::contextMenuSelected(int id)
 {
     qDebug("Id selected: %i",id);
     switch (id) {
     case 0:
         refreshFolders(true);
         break;
     case 1:
         createNewFolder();
         break;
     case 2:
         removeChilds();
         wrapper->logout();
         break;
+    case 3:
+        if (account->getOffline()==false) {
+            removeChilds();
+            wrapper->logout();
+        }
+        account->setOffline(!account->getOffline());
+        account->save();
+        refreshFolders(false);
+    break;
     default:
         break;
     }
 }
 
 RecBody IMAPviewItem::fetchBody(const RecMail&)
 {
     return RecBody();
 }
 
-IMAPfolderItem::~IMAPfolderItem()
+bool IMAPviewItem::offline()
 {
-    delete folder;
+    return account->getOffline();
 }
 
 IMAPfolderItem::IMAPfolderItem( Folder *folderInit, IMAPviewItem *parent , QListViewItem*after )
     : AccountViewItem( parent , after )
 {
     folder = folderInit;
     imap = parent;
     if (folder->getDisplayName().lower()!="inbox") {
         setPixmap( 0, PIXMAP_IMAPFOLDER );
     } else {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     }
     setText( 0, folder->getDisplayName() );
 }
 
 IMAPfolderItem::IMAPfolderItem( Folder *folderInit, IMAPfolderItem *parent , QListViewItem*after, IMAPviewItem *master  )
     : AccountViewItem( parent,after )
 {
     folder = folderInit;
     imap = master;
     if (folder->getDisplayName().lower()!="inbox") {
         setPixmap( 0, PIXMAP_IMAPFOLDER );
     } else {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     }
     setText( 0, folder->getDisplayName() );
 }
 
+IMAPfolderItem::~IMAPfolderItem()
+{
+    delete folder;
+}
+
 const QString& IMAPfolderItem::Delemiter()const
 {
     return folder->Separator();
 }
 
 bool IMAPfolderItem::matchName(const QString&name)const
 {
     return folder->getDisplayName()==name;
 }
 
 void IMAPfolderItem::refresh(QList<RecMail>&target)
 {
     if (folder->may_select()) {
         imap->getWrapper()->listMessages( folder->getName(),target );
     } else {
         target.clear();
     }
 }
 
 RecBody IMAPfolderItem::fetchBody(const RecMail&aMail)
 {
     return imap->getWrapper()->fetchBody(aMail);
 }
 
 QPopupMenu * IMAPfolderItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m) {
         if (folder->may_select()) {
             m->insertItem(QObject::tr("Refresh header list",contextName),0);
+            m->insertItem(QObject::tr("Move/Copie all mails",contextName),4);
             m->insertItem(QObject::tr("Delete all mails",contextName),1);
         }
         if (folder->no_inferior()==false) {
             m->insertItem(QObject::tr("Create new subfolder",contextName),2);
         }
         if (folder->getDisplayName().lower()!="inbox") {
             m->insertItem(QObject::tr("Delete folder",contextName),3);
         }
     }
     return m;
 }
 
 void IMAPfolderItem::createNewFolder()
 {
     Newmdirdlg ndirdlg;
     ndirdlg.showMaximized();
     if (ndirdlg.exec()) {
         QString ndir = ndirdlg.Newdir();
         bool makesubs = ndirdlg.subpossible();
         QString delemiter = Delemiter();
         if (imap->wrapper->createMbox(ndir,folder,delemiter,makesubs)) {
             imap->refreshFolders(true);
         }
     }
 }
 
 void IMAPfolderItem::deleteFolder()
 {
     int yesno = QMessageBox::warning(0,QObject::tr("Delete folder",contextName),
         QObject::tr("<center>Realy delete folder <br><b>%1</b><br>and all if it content?</center>",contextName).arg(folder->getDisplayName()),
         QObject::tr("Yes",contextName),
         QObject::tr("No",contextName),QString::null,1,1);
     qDebug("Auswahl: %i",yesno);
     if (yesno == 0) {
         if (imap->getWrapper()->deleteMbox(folder)) {
             QListView*v=listView();
             IMAPviewItem * box = imap;
             /* be carefull - after that this object is destroyd so don't use
              * any member of it after that call!!*/
             imap->refreshFolders(true);
             if (v) {
                 v->setSelected(box,true);
             }
         }
     }
 }
 
+void IMAPfolderItem::downloadMails()
+{
+    AccountView*bl = imap->accountView();
+    if (!bl) return;
+    bl->downloadMails(folder,imap->getWrapper());
+}
+
 void IMAPfolderItem::contextMenuSelected(int id)
 {
     qDebug("Selected id: %i",id);
     AccountView * view = (AccountView*)listView();
     switch(id) {
     case 0:
         view->refreshCurrent();
         break;
     case 1:
         deleteAllMail(imap->getWrapper(),folder);
         break;
     case 2:
         createNewFolder();
         break;
     case 3:
         deleteFolder();
         break;
+    case 4:
+        downloadMails();
+        break;
     default:
         break;
     }
 }
 
 /**
  * Generic stuff
  */
 
 const QString AccountViewItem::contextName="AccountViewItem";
 
+AccountViewItem::AccountViewItem( AccountView *parent ) 
+    : QListViewItem( parent )
+{
+    m_Backlink = parent;
+}
+
+AccountViewItem::AccountViewItem( QListViewItem *parent)
+    : QListViewItem( parent) 
+{
+    m_Backlink = 0;
+}
+
+AccountViewItem::AccountViewItem( QListViewItem *parent , QListViewItem*after  )
+    :QListViewItem( parent,after )
+{
+    m_Backlink = 0;
+}
+
+AccountViewItem::~AccountViewItem()
+{
+}
+
+AccountView*AccountViewItem::accountView()
+{
+    return m_Backlink;
+}
+
 void AccountViewItem::deleteAllMail(AbstractMail*wrapper,Folder*folder)
 {
     if (!wrapper) return;
     QString fname="";
     if (folder) fname = folder->getDisplayName();
     int yesno = QMessageBox::warning(0,QObject::tr("Delete all mails",contextName),
         QObject::tr("<center>Realy delete all mails in box <br>%1</center>",contextName).
             arg(fname),
         QObject::tr("Yes",contextName),
         QObject::tr("No",contextName),QString::null,1,1);
     qDebug("Auswahl: %i",yesno);
     if (yesno == 0) {
         if (wrapper->deleteAllMail(folder)) {
             AccountView * view = (AccountView*)listView();
             if (view) view->refreshCurrent();
         }
     }
 }
 
 AccountView::AccountView( QWidget *parent, const char *name, WFlags flags )
     : QListView( parent, name, flags )
 {
     connect( this, SIGNAL( selectionChanged( QListViewItem * ) ),
             SLOT( refresh( QListViewItem * ) ) );
     connect( this, SIGNAL( mouseButtonPressed(int, QListViewItem *,const QPoint&,int  ) ),this,
             SLOT( slotHold( int, QListViewItem *,const QPoint&,int  ) ) );
 
     setSorting(0);
 }
 
+AccountView::~AccountView()
+{
+    imapAccounts.clear();
+    mboxAccounts.clear();
+}
+
 void AccountView::slotContextMenu(int id)
 {
     AccountViewItem *view = static_cast<AccountViewItem *>(currentItem());
     if (!view) return;
     view->contextMenuSelected(id);
 }
 
 void AccountView::slotHold(int button, QListViewItem * item,const QPoint&,int)
 {
     if (button==1) {return;}
     if (!item) return;
     AccountViewItem *view = static_cast<AccountViewItem *>(item);
     QPopupMenu*m = view->getContextMenu();
     if (!m) return;
     connect(m,SIGNAL(activated(int)),this,SLOT(slotContextMenu(int)));
     m->setFocus();
     m->exec( QPoint( QCursor::pos().x(), QCursor::pos().y()) );
     delete m;
 }
 
 void AccountView::populate( QList<Account> list )
 {
     clear();
 
-    (void) new MBOXviewItem(AbstractMail::defaultLocalfolder(),this);
+    imapAccounts.clear();
+    mboxAccounts.clear();
+
+    mboxAccounts.append(new MBOXviewItem(AbstractMail::defaultLocalfolder(),this));
 
     Account *it;
     for ( it = list.first(); it; it = list.next() ) {
         if ( it->getType().compare( "IMAP" ) == 0 ) {
             IMAPaccount *imap = static_cast<IMAPaccount *>(it);
             qDebug( "added IMAP " + imap->getAccountName() );
-            (void) new IMAPviewItem( imap, this );
+            imapAccounts.append(new IMAPviewItem( imap, this ));
         } else if ( it->getType().compare( "POP3" ) == 0 ) {
             POP3account *pop3 = static_cast<POP3account *>(it);
             qDebug( "added POP3 " + pop3->getAccountName() );
+            /* must not be hold 'cause it isn't required */
             (void) new POP3viewItem( pop3, this );
         }
     }
 }
 
 void AccountView::refresh(QListViewItem *item) {
 
     qDebug("AccountView refresh...");
     if ( item ) {
         m_currentItem = item;
         QList<RecMail> headerlist;
         headerlist.setAutoDelete(true);
         AccountViewItem *view = static_cast<AccountViewItem *>(item);
         view->refresh(headerlist);
         emit refreshMailview(&headerlist);
     }
 }
 
 void AccountView::refreshCurrent()
 {
     m_currentItem = currentItem();
-   if ( !m_currentItem ) return;
-   QList<RecMail> headerlist;
-   headerlist.setAutoDelete(true);
-   AccountViewItem *view = static_cast<AccountViewItem *>(m_currentItem);
-   view->refresh(headerlist);
-   emit refreshMailview(&headerlist);
+    if ( !m_currentItem ) return;
+    QList<RecMail> headerlist;
+    headerlist.setAutoDelete(true);
+    AccountViewItem *view = static_cast<AccountViewItem *>(m_currentItem);
+    view->refresh(headerlist);
+    emit refreshMailview(&headerlist);
 }
 
 void AccountView::refreshAll()
 {
 
 }
 
 RecBody AccountView::fetchBody(const RecMail&aMail)
 {
     QListViewItem*item = selectedItem ();
     if (!item) return RecBody();
     AccountViewItem *view = static_cast<AccountViewItem *>(item);
     return view->fetchBody(aMail);
 }
 
+void AccountView::setupFolderselect(Selectstore*sels)
+{
+    sels->showMaximized();
+    QStringList sFolders;
+    unsigned int i = 0;
+    for (i=0; i < mboxAccounts.count();++i) {
+        mboxAccounts[i]->refresh(false);
+        sFolders = mboxAccounts[i]->subFolders();
+        sels->addAccounts(mboxAccounts[i]->getWrapper(),sFolders);
+    }
+    for (i=0; i < imapAccounts.count();++i) {
+        if (imapAccounts[i]->offline())
+            continue;
+        imapAccounts[i]->refreshFolders(false);
+        sels->addAccounts(imapAccounts[i]->getWrapper(),imapAccounts[i]->subFolders());
+    }
+}
+
+void AccountView::downloadMails(Folder*fromFolder,AbstractMail*fromWrapper)
+{
+    unsigned int i = 0;
+    AbstractMail*targetMail = 0;
+    QString targetFolder = "";
+    Selectstore sels;
+    setupFolderselect(&sels);
+    if (!sels.exec()) return;
+    targetMail = sels.currentMail();
+    targetFolder = sels.currentFolder();
+    if ( (fromWrapper==targetMail && fromFolder->getName()==targetFolder) ||
+        targetFolder.isEmpty()) {
+        return;
+    }
+
+    QList<RecMail> t;
+    fromWrapper->listMessages(fromFolder->getName(),t);
+    encodedString*st = 0;
+    for (i = 0; i < t.count();++i) {
+        RecMail*r = t.at(i);
+        st = fromWrapper->fetchRawBody(*r);
+        if (st) {
+            targetMail->storeMessage(st->Content(),st->Length(),targetFolder);
+            delete st;
+        }
+    }
+}
+
 /**
  * MBOX Account stuff
  */
 
-MBOXviewItem::MBOXviewItem( const QString&aPath, QListView *parent )
+MBOXviewItem::MBOXviewItem( const QString&aPath, AccountView *parent )
     : AccountViewItem( parent )
 {
     m_Path = aPath;
-    wrapper = AbstractMail::getWrapper( m_Path );
+    /* be carefull - the space within settext is wanted - thats why the string twice */
+    wrapper = AbstractMail::getWrapper( m_Path,"Local Folders");
     setPixmap( 0, PIXMAP_LOCALFOLDER );
     setText( 0, " Local Folders" );
     setOpen( true );
 }
 
 MBOXviewItem::~MBOXviewItem()
 {
     delete wrapper;
 }
 
 AbstractMail *MBOXviewItem::getWrapper()
 {
     return wrapper;
 }
 
 void MBOXviewItem::refresh( QList<RecMail> & )
 {
     refresh(false);
 }
 
 void MBOXviewItem::refresh(bool force)
 {
     if (childCount()>0 && force==false) return;
     QList<Folder> *folders = wrapper->listFolders();
     QListViewItem *child = firstChild();
     while ( child ) {
         QListViewItem *tmp = child;
         child = child->nextSibling();
         delete tmp;
     }
     Folder *it;
     QListViewItem*item = 0;
     for ( it = folders->first(); it; it = folders->next() ) {
         item = new MBOXfolderItem( it, this , item );
         item->setSelectable(it->may_select());
     }
     // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     folders->setAutoDelete(false);
     delete folders;
 }
 
 RecBody MBOXviewItem::fetchBody( const RecMail &mail )
 {
     qDebug( "MBOX fetchBody" );
     return wrapper->fetchBody( mail );
 }
 
 QPopupMenu * MBOXviewItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m) {
         m->insertItem(QObject::tr("Refresh folder list",contextName),0);
         m->insertItem(QObject::tr("Create new folder",contextName),1);
     }
     return m;
 }
 
 void MBOXviewItem::createFolder()
 {
     Newmdirdlg ndirdlg(0,0,true);
     ndirdlg.showMaximized();
     if (ndirdlg.exec()) {
         QString ndir = ndirdlg.Newdir();
         if (wrapper->createMbox(ndir)) {
             refresh(true);
         }
     }
 }
 
+QStringList MBOXviewItem::subFolders()
+{
+    QStringList result;
+    QListViewItem *child = firstChild();
+    while ( child ) {
+        MBOXfolderItem *tmp = (MBOXfolderItem*)child;
+        child = child->nextSibling();
+        result.append(tmp->getFolder()->getName());
+    }
+    qDebug("Size of result: %i",result.count());
+    return result;
+}
+
 void MBOXviewItem::contextMenuSelected(int which)
 {
     switch (which) {
     case 0:
         refresh(true);
         break;
     case 1:
         createFolder();
         break;
     default:
         break;
     }
 }
 
 MBOXfolderItem::~MBOXfolderItem()
 {
     delete folder;
 }
 
 MBOXfolderItem::MBOXfolderItem( Folder *folderInit, MBOXviewItem *parent , QListViewItem*after  )
     : AccountViewItem( parent,after )
 {
     folder = folderInit;
     mbox = parent;
     if (folder->getDisplayName().lower() == "outgoing") {
         setPixmap( 0, PIXMAP_OUTBOXFOLDER );
     } else if (folder->getDisplayName().lower() == "inbox") {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     } else {
         setPixmap( 0, PIXMAP_MBOXFOLDER );
         }
     setText( 0, folder->getDisplayName() );
 }
 
+Folder*MBOXfolderItem::getFolder()
+{
+    return folder;
+}
+
 void MBOXfolderItem::refresh(QList<RecMail>&target)
 {
     if (folder->may_select())
         mbox->getWrapper()->listMessages( folder->getName(),target );
 }
 
 RecBody MBOXfolderItem::fetchBody(const RecMail&aMail)
 {
     return mbox->getWrapper()->fetchBody(aMail);
 }
 
 void MBOXfolderItem::deleteFolder()
 {
     int yesno = QMessageBox::warning(0,QObject::tr("Delete folder",contextName),
         QObject::tr("<center>Realy delete folder <br><b>%1</b><br>and all if it content?</center>",contextName).arg(folder->getDisplayName()),
         QObject::tr("Yes",contextName),
         QObject::tr("No",contextName),QString::null,1,1);
     qDebug("Auswahl: %i",yesno);
     if (yesno == 0) {
         if (mbox->getWrapper()->deleteMbox(folder)) {
             QListView*v=listView();
             MBOXviewItem * box = mbox;
             /* be carefull - after that this object is destroyd so don't use
              * any member of it after that call!!*/
             mbox->refresh(true);
             if (v) {
                 v->setSelected(box,true);
             }
         }
     }
 }
 
 QPopupMenu * MBOXfolderItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m) {
         m->insertItem(QObject::tr("Delete all mails",contextName),0);
         m->insertItem(QObject::tr("Delete folder",contextName),1);
     }
     return m;
 }
 
 void MBOXfolderItem::contextMenuSelected(int which)
 {
     switch(which) {
     case 0:
         deleteAllMail(mbox->getWrapper(),folder);
         break;
     case 1:
         deleteFolder();
         break;
     default:
         break;
     }
 }
diff --git a/noncore/net/mail/accountview.h b/noncore/net/mail/accountview.h
index 7131192..48f52c7 100644
--- a/noncore/net/mail/accountview.h
+++ b/noncore/net/mail/accountview.h
@@ -1,179 +1,188 @@
 #ifndef ACCOUNTVIEW_H
 #define ACCOUNTVIEW_H
 
 #include <qlistview.h>
 #include <qlist.h>
 
 #include <libmailwrapper/settings.h>
 #include <libmailwrapper/mailwrapper.h>
 #include <libmailwrapper/abstractmail.h>
 
 class POP3wrapper;
 class RecMail;
 class RecBody;
 class QPopupMenu;
+class Selectstore;
+class AccountView;
 
 class AccountViewItem : public QListViewItem
 {
         
 public:
-    AccountViewItem( QListView *parent ) : QListViewItem( parent ) {}
-    AccountViewItem( QListViewItem *parent) : QListViewItem( parent) {}
-    AccountViewItem( QListViewItem *parent , QListViewItem*after  ) : QListViewItem( parent,after ) {}
+    AccountViewItem( AccountView *parent );
+    AccountViewItem( QListViewItem *parent);
+    AccountViewItem( QListViewItem *parent , QListViewItem*after  );
+    virtual ~AccountViewItem();
     virtual void refresh(QList<RecMail>&)=0;
     virtual RecBody fetchBody(const RecMail&)=0;
     virtual QPopupMenu * getContextMenu(){return 0;};
     virtual void contextMenuSelected(int){}
+    virtual AccountView*accountView();
 protected:
     virtual void deleteAllMail(AbstractMail*wrapper,Folder*f);
     static const QString contextName;
+    AccountView*m_Backlink;
 };
 
 class POP3viewItem : public AccountViewItem
 {
 
 public:
-    POP3viewItem( POP3account *a, QListView *parent );
-    ~POP3viewItem();
+    POP3viewItem( POP3account *a, AccountView *parent );
+    virtual ~POP3viewItem();
     virtual void refresh( QList<RecMail> &target );
     virtual RecBody fetchBody( const RecMail &mail );
     AbstractMail *getWrapper();
-private:
+    virtual QPopupMenu * getContextMenu();
+    virtual void contextMenuSelected(int);
+
+protected:
     POP3account *account;
     AbstractMail *wrapper;
-
+    void disconnect();
+    void setOnOffline();
 };
 
 class POP3folderItem : public AccountViewItem
 {
 
 public:
     POP3folderItem( Folder *folder, POP3viewItem *parent , QListViewItem*after  );
-    ~POP3folderItem();
+    virtual ~POP3folderItem();
     virtual void refresh(QList<RecMail>&);
     virtual RecBody fetchBody(const RecMail&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
 
 protected:
     void downloadMails();
-
-private:
     Folder *folder;
     POP3viewItem *pop3;
 };
 
 class IMAPfolderItem;
 
 class IMAPviewItem : public AccountViewItem
 {
     friend class IMAPfolderItem;
 public:
-    IMAPviewItem( IMAPaccount *a, QListView *parent );
-    ~IMAPviewItem();
+    IMAPviewItem( IMAPaccount *a, AccountView *parent );
+    virtual ~IMAPviewItem();
     virtual void refresh(QList<RecMail>&);
     virtual RecBody fetchBody(const RecMail&);
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
+    const QStringList&subFolders();
+    virtual void refreshFolders(bool force=false);
+    bool offline();
 
 protected:
     IMAPfolderItem*findSubItem(const QString&path,IMAPfolderItem*start=0);
-    virtual void refreshFolders(bool force=false);
     virtual void createNewFolder();
     virtual void removeChilds();
-
-private:
     IMAPaccount *account;
     AbstractMail *wrapper;
+    QStringList currentFolders;
 };
 
 class IMAPfolderItem : public AccountViewItem
 {
 
 public:
     IMAPfolderItem( Folder *folder, IMAPviewItem *parent , QListViewItem*after  );
     IMAPfolderItem( Folder *folder, IMAPfolderItem *parent , QListViewItem*after, IMAPviewItem *master  );
-    ~IMAPfolderItem();
+    virtual ~IMAPfolderItem();
     virtual void refresh(QList<RecMail>&);
     virtual RecBody fetchBody(const RecMail&);
     bool matchName(const QString&name)const;
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
     virtual const QString& Delemiter()const;
 protected:
     virtual void createNewFolder();
     virtual void deleteFolder();
-    
-private:
+    virtual void downloadMails();
     Folder *folder;
     IMAPviewItem *imap;
 };
 
 class MBOXviewItem : public AccountViewItem
 {
     friend class MBOXfolderItem;
 
 public:
-//    MBOXviewItem( MBOXaccount *a, QListView *parent );
-    MBOXviewItem( const QString&aMboxPath, QListView *parent );
-    ~MBOXviewItem();
+    MBOXviewItem( const QString&aMboxPath, AccountView *parent );
+    virtual ~MBOXviewItem();
     virtual void refresh( QList<RecMail> &target );
     virtual RecBody fetchBody( const RecMail &mail );
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
+    QStringList subFolders();
+    virtual void refresh(bool force=false);
 
 protected:
-    virtual void refresh(bool force=false);
     virtual void createFolder();
-
-private:
-//    MBOXaccount *account;
     QString m_Path;
     AbstractMail *wrapper;
 
 };
 
 class MBOXfolderItem : public AccountViewItem
 {
 
 public:
     MBOXfolderItem( Folder *folder, MBOXviewItem *parent , QListViewItem*after  );
-    ~MBOXfolderItem();
+    virtual ~MBOXfolderItem();
     virtual void refresh(QList<RecMail>&);
     virtual RecBody fetchBody(const RecMail&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
+    virtual Folder*getFolder();
 
 protected:
     virtual void deleteFolder();
-private:
     Folder *folder;
     MBOXviewItem *mbox;
 };
 
 class AccountView : public QListView
 {
     Q_OBJECT
 
 public:
     AccountView( QWidget *parent = 0, const char *name = 0, WFlags flags = 0 );
-    void populate( QList<Account> list );
-    RecBody fetchBody(const RecMail&aMail);
+    virtual ~AccountView();
+    virtual void populate( QList<Account> list );
+    virtual RecBody fetchBody(const RecMail&aMail);
+    virtual void downloadMails(Folder*fromFolder,AbstractMail*fromWrapper);
 
 public slots:
     virtual void refreshAll();
     virtual void refresh(QListViewItem *item);
     virtual void refreshCurrent();
     virtual void slotHold(int, QListViewItem *,const QPoint&,int);
     virtual void slotContextMenu(int id);
+    void setupFolderselect(Selectstore*sels);
 
 signals:
     void refreshMailview(QList<RecMail>*);  
 
-private: 
-    QListViewItem* m_currentItem; 
+protected: 
+    QListViewItem* m_currentItem;
+    QValueList<IMAPviewItem*> imapAccounts;
+    QValueList<MBOXviewItem*> mboxAccounts;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/abstractmail.cpp b/noncore/net/mail/libmailwrapper/abstractmail.cpp
index 80d0b52..3dd2fce 100644
--- a/noncore/net/mail/libmailwrapper/abstractmail.cpp
+++ b/noncore/net/mail/libmailwrapper/abstractmail.cpp
@@ -1,101 +1,106 @@
 #include "abstractmail.h"
 #include "imapwrapper.h"
 #include "pop3wrapper.h"
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 
 #include <qstring.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <stdlib.h>
 #include <libetpan/mailmime_content.h>
 #include <libetpan/mailmime.h>
 
 AbstractMail* AbstractMail::getWrapper(IMAPaccount *a)
 {
     return new IMAPwrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(POP3account *a)
 {
     return new POP3wrapper(a);
 }
 
-AbstractMail* AbstractMail::getWrapper(const QString&a)
+AbstractMail* AbstractMail::getWrapper(const QString&a,const QString&name)
 {
-    return new MBOXwrapper(a);
+    return new MBOXwrapper(a,name);
 }
 
 encodedString* AbstractMail::decode_String(const encodedString*text,const QString&enc)
 {
     qDebug("Decode string start");
     char*result_text;
     size_t index = 0;
     /* reset for recursive use! */
     size_t target_length = 0;
     result_text = 0;
     int mimetype = MAILMIME_MECHANISM_7BIT;
     if (enc.lower()=="quoted-printable") {
         mimetype = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
     } else if (enc.lower()=="base64") {
         mimetype = MAILMIME_MECHANISM_BASE64;
     } else if (enc.lower()=="8bit") {
         mimetype = MAILMIME_MECHANISM_8BIT;
     } else if (enc.lower()=="binary") {
         mimetype = MAILMIME_MECHANISM_BINARY;
     }
 
     int err = mailmime_part_parse(text->Content(),text->Length(),&index,mimetype,
     &result_text,&target_length);
     
     encodedString* result = new encodedString();
     if (err == MAILIMF_NO_ERROR) {
         result->setContent(result_text,target_length);
     }
     qDebug("Decode string finished");
     return result;
 }
 
 QString AbstractMail::convert_String(const char*text)
 {
     size_t index = 0;
     char*res = 0;
    
     /* attention - doesn't work with arm systems! */
     int err = mailmime_encoded_phrase_parse("iso-8859-1",
         text, strlen(text),&index, "iso-8859-1",&res);
     if (err != MAILIMF_NO_ERROR) {
         if (res) free(res);
         return QString(text);
     }
     if (res) {
         QString result(res);
         free(res);
         return result;
     }
     return QString(text);
 }
 
 /* cp & paste from launcher */
 QString AbstractMail::gen_attachment_id()
 {
     QFile file( "/proc/sys/kernel/random/uuid" );
     if (!file.open(IO_ReadOnly ) )
         return QString::null;
 
     QTextStream stream(&file);
 
     return "{" + stream.read().stripWhiteSpace() + "}";
 }
 
 int AbstractMail::createMbox(const QString&,const Folder*,const QString& delemiter,bool)
 {
     return 0;
 }
 
 QString AbstractMail::defaultLocalfolder()
 {
     QString f = getenv( "HOME" );
     f += "/Applications/opiemail/localmail";
     return f;
 }
+
+/* temporary - will be removed when implemented in all classes */
+void AbstractMail::deleteMails(const QString &,QList<RecMail> &)
+{
+}
diff --git a/noncore/net/mail/libmailwrapper/abstractmail.h b/noncore/net/mail/libmailwrapper/abstractmail.h
index 9770991..15d83cb 100644
--- a/noncore/net/mail/libmailwrapper/abstractmail.h
+++ b/noncore/net/mail/libmailwrapper/abstractmail.h
@@ -1,60 +1,62 @@
 #ifndef __abstract_mail_
 #define __abstract_mail_
 
 #include <qobject.h>
 #include "settings.h"
 
 class RecMail;
 class RecBody;
 class RecPart;
 class IMAPwrapper;
 class POP3wrapper;
 class Folder;
 class encodedString;
 struct folderStat;
 
 class AbstractMail:public QObject
 {
     Q_OBJECT
 public:
     AbstractMail(){};
     virtual ~AbstractMail(){}
     virtual QList<Folder>* listFolders()=0;
     virtual void listMessages(const QString & mailbox,QList<RecMail>&target )=0;
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX")=0;
     virtual RecBody fetchBody(const RecMail&mail)=0;
     virtual QString fetchTextPart(const RecMail&mail,const RecPart&part)=0;
     virtual encodedString* fetchDecodedPart(const RecMail&mail,const RecPart&part)=0;
     virtual encodedString* fetchRawPart(const RecMail&mail,const RecPart&part)=0;
     virtual encodedString* fetchRawBody(const RecMail&mail)=0;
 
     virtual void deleteMail(const RecMail&mail)=0;
     virtual void answeredMail(const RecMail&mail)=0;
     virtual int deleteAllMail(const Folder*)=0;
+    virtual void deleteMails(const QString & FolderName,QList<RecMail> &target);
     virtual int deleteMbox(const Folder*)=0;
     virtual void storeMessage(const char*msg,size_t length, const QString&folder)=0;
 
     virtual void cleanMimeCache(){};    
     /* mail box methods */
     /* parameter is the box to create.
      * if the implementing subclass has prefixes, 
      * them has to be appended automatic.
      */
     virtual int createMbox(const QString&,const Folder*parentfolder=0,const QString& delemiter="/",bool getsubfolder=false);
     virtual void logout()=0;
     
     static AbstractMail* getWrapper(IMAPaccount *a);
     static AbstractMail* getWrapper(POP3account *a);
     /* mbox only! */
-    static AbstractMail* getWrapper(const QString&a);
+    static AbstractMail* getWrapper(const QString&a,const QString&name="Local Folders");
 
     static QString defaultLocalfolder();
     
     virtual const QString&getType()const=0;
+    virtual const QString&getName()const=0;
 
 protected:
     static encodedString*decode_String(const encodedString*text,const QString&enc);
     static QString convert_String(const char*text);
     static QString gen_attachment_id();
 };
 #endif
diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.cpp b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
index d252159..bb74de9 100644
--- a/noncore/net/mail/libmailwrapper/imapwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
@@ -1,223 +1,224 @@
 #include <stdlib.h>
 #include <libetpan/libetpan.h>
 #include <qpe/global.h>
 
 #include "imapwrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 
 IMAPwrapper::IMAPwrapper( IMAPaccount *a )
     : AbstractMail()
 {
     account = a;
     m_imap = 0;
 }
 
 IMAPwrapper::~IMAPwrapper()
 {
     logout();
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     qDebug( "IMAP: %i of %i", current, maximum );
 }
 
 void IMAPwrapper::login()
 {
     const char *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().latin1();
     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().latin1();
                 pass = login.getPassword().latin1();
           } else {
                 // cancel
                 qDebug( "IMAP: Login canceled" );
                 return;
           }
         } else {
           user = account->getUser().latin1();
           pass = account->getPassword().latin1();
         }
 
     m_imap = mailimap_new( 20, &imap_progress );
 
     /* connect */
     if (account->getSSL()) {
         err = mailimap_ssl_connect( m_imap, (char*)server, port );
     } else {
         err = mailimap_socket_connect( m_imap, (char*)server, 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(tr("error connecting imap server: %1").arg(failure));
          mailimap_free( m_imap );
          m_imap = 0;
          return;
     }
 
     /* login */
     err = mailimap_login_simple( m_imap, (char*)user, (char*)pass );
     if ( err != MAILIMAP_NO_ERROR ) {
         Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response));
         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;
 }
 
 void IMAPwrapper::listMessages(const QString&mailbox,QList<RecMail> &target )
 {
     const char *mb = 0;
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current;
 //    mailimap_fetch_att *fetchAtt,*fetchAttFlags,*fetchAttDate,*fetchAttSize;
     mailimap_fetch_type *fetchType = 0;
     mailimap_set *set = 0;
 
     mb = mailbox.latin1();
     login();
     if (!m_imap) {
         return;
     }
     /* select mailbox READONLY for operations */
     err = mailimap_examine( m_imap, (char*)mb);
     if ( err != MAILIMAP_NO_ERROR ) {
         Global::statusMessage(tr("error selecting mailbox: %1").arg(m_imap->imap_response));
         return;
     }
 
     int last = m_imap->imap_selection_info->sel_exists;
 
     if (last == 0) {
         Global::statusMessage(tr("Mailbox has no mails"));
         return;
     } else {
         Global::statusMessage(tr("Mailbox has %1 mails").arg(last));
     }
 
     /* the range has to start at 1!!! not with 0!!!! */
     set = mailimap_set_new_interval( 1, 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 ) {
         mailimap_msg_att * msg_att;
         int i = 0;
         for (current = clist_begin(result); current != 0; current=clist_next(current)) {
             ++i;
             msg_att = (mailimap_msg_att*)current->data;
             RecMail*m = parse_list_result(msg_att);
             if (m) {
                 m->setNumber(i);
                 m->setMbox(mailbox);
                 m->setWrapper(this);
                 target.append(m);
             }
         }
     } else {
         Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response));
     }
     if (result) mailimap_fetch_list_free(result);
 }
 
 QList<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;
 
     QList<Folder> * folders = new QList<Folder>();
     folders->setAutoDelete( false );
     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.
  */
     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: %s",m_imap->imap_response);
     }
     mailimap_list_result_free( result );
 
@@ -817,198 +818,203 @@ void IMAPwrapper::answeredMail(const RecMail&mail)
     }
     flist = mailimap_flag_list_new_empty();
     mailimap_flag_list_add(flist,mailimap_flag_new_answered());
     store_flags = mailimap_store_att_flags_new_add_flags(flist);
     set = mailimap_set_new_single(mail.getNumber());
     err = mailimap_store(m_imap,set,store_flags);
     mailimap_set_free( set );
     mailimap_store_att_flags_free(store_flags);
 
     if (err != MAILIMAP_NO_ERROR) {
         qDebug("error marking mail: %s",m_imap->imap_response);
         return;
     }
 }
 
 QString IMAPwrapper::fetchTextPart(const RecMail&mail,const QValueList<int>&path,bool internal_call,const QString&enc)
 {
     QString body("");
     encodedString*res = fetchRawPart(mail,path,internal_call);
     encodedString*r = decode_String(res,enc);
     delete res;
     if (r) {
         if (r->Length()>0) {
             body = r->Content();
         }
         delete r;
     }
     return body;
 }
 
 QString IMAPwrapper::fetchTextPart(const RecMail&mail,const RecPart&part)
 {
     return fetchTextPart(mail,part.Positionlist(),false,part.Encoding());
 }
 
 encodedString* IMAPwrapper::fetchDecodedPart(const RecMail&mail,const RecPart&part)
 {
     encodedString*res = fetchRawPart(mail,part.Positionlist(),false);
     encodedString*r = decode_String(res,part.Encoding());
     delete res;
     return r;
 }
 
 encodedString* IMAPwrapper::fetchRawPart(const RecMail&mail,const RecPart&part)
 {
     return fetchRawPart(mail,part.Positionlist(),false);
 }
 
 int IMAPwrapper::deleteAllMail(const Folder*folder)
 {
     login();
     if (!m_imap) {
         return 0;
     }
     mailimap_flag_list*flist;
     mailimap_set *set;
     mailimap_store_att_flags * store_flags;
     int err = mailimap_select( m_imap, folder->getName().latin1());
     if ( err != MAILIMAP_NO_ERROR ) {
         Global::statusMessage(tr("error selecting mailbox: %1").arg(m_imap->imap_response));
         return 0;
     }
     int last = m_imap->imap_selection_info->sel_exists;
     if (last == 0) {
         Global::statusMessage(tr("Mailbox has no mails!"));
         return 0;
     }
     flist = mailimap_flag_list_new_empty();
     mailimap_flag_list_add(flist,mailimap_flag_new_deleted());
     store_flags = mailimap_store_att_flags_new_set_flags(flist);
     set = mailimap_set_new_interval( 1, last );
     err = mailimap_store(m_imap,set,store_flags);
     mailimap_set_free( set );
     mailimap_store_att_flags_free(store_flags);
     if (err != MAILIMAP_NO_ERROR) {
         Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response));
         return 0;
     }
     qDebug("deleting mail: %s",m_imap->imap_response);
     /* should we realy do that at this moment? */
     err = mailimap_expunge(m_imap);
     if (err != MAILIMAP_NO_ERROR) {
         Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response));
         return 0;
     }
     qDebug("Delete successfull %s",m_imap->imap_response);
     return 1;
 }
 
 int IMAPwrapper::createMbox(const QString&folder,const Folder*parentfolder,const QString& delemiter,bool getsubfolder)
 {
     if (folder.length()==0) return 0;
     login();
     if (!m_imap) {return 0;}
     QString pre = account->getPrefix();
     if (delemiter.length()>0 && pre.findRev(delemiter)!=pre.length()-1) {
         pre+=delemiter;
     }
     if (parentfolder) {
         pre += parentfolder->getDisplayName()+delemiter;
     }
     pre+=folder;
     if (getsubfolder) {
         if (delemiter.length()>0) {
             pre+=delemiter;
         } else {
             Global::statusMessage(tr("Cannot create folder %1 for holding subfolders").arg(pre));
             return 0;
         }
     }
     qDebug("Creating %s",pre.latin1());
     int res = mailimap_create(m_imap,pre.latin1());
     if (res != MAILIMAP_NO_ERROR) {
         Global::statusMessage(tr("%1").arg(m_imap->imap_response));
         return 0;
     }
     return 1;
 }
 
 int IMAPwrapper::deleteMbox(const Folder*folder)
 {
     if (!folder) return 0;
     login();
     if (!m_imap) {return 0;}
     int res = mailimap_delete(m_imap,folder->getName());
     if (res != MAILIMAP_NO_ERROR) {
         Global::statusMessage(tr("%1").arg(m_imap->imap_response));
         return 0;
     }
     return 1;
 }
 
 void IMAPwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     mailimap_status_att_list * att_list =0;
     mailimap_mailbox_data_status * status=0;
     clistiter * cur = 0;
     int r = 0;
     int res = 0;
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     login();
     if (!m_imap) {
         return;
     }
     att_list = mailimap_status_att_list_new_empty();
     if (!att_list) return;
     r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_MESSAGES);
     r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_RECENT);
     r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_UNSEEN);
     r = mailimap_status(m_imap, mailbox.latin1(), att_list, &status);
     if (r==MAILIMAP_NO_ERROR&&status->st_info_list!=0) {
         for (cur = clist_begin(status->st_info_list);
                 cur != NULL ; cur = clist_next(cur)) {
             mailimap_status_info * status_info;
             status_info = (mailimap_status_info *)clist_content(cur);
             switch (status_info->st_att) {
             case MAILIMAP_STATUS_ATT_MESSAGES:
                 target_stat.message_count = status_info->st_value;
             break;
             case MAILIMAP_STATUS_ATT_RECENT:
                 target_stat.message_recent = status_info->st_value;
             break;
             case MAILIMAP_STATUS_ATT_UNSEEN:
                 target_stat.message_unseen = status_info->st_value;
             break;
             }
         }
     } else {
         qDebug("Error retrieving status");
     }
     if (status) mailimap_mailbox_data_status_free(status);
     if (att_list) mailimap_status_att_list_free(att_list);
 }
 
 void IMAPwrapper::storeMessage(const char*msg,size_t length, const QString&folder)
 {
     login();
     if (!m_imap) return;
     if (!msg) return;
     int r = mailimap_append(m_imap,(char*)folder.latin1(),0,0,msg,length);
     if (r != MAILIMAP_NO_ERROR) {
         Global::statusMessage("Error storing mail!");
     }
 }
 
 const QString&IMAPwrapper::getType()const
 {
     return account->getType();
 }
 
+const QString&IMAPwrapper::getName()const
+{
+    return account->getAccountName();
+}
+
 encodedString* IMAPwrapper::fetchRawBody(const RecMail&mail)
 {
     // dummy
     QValueList<int> path;
     return fetchRawPart(mail,path,false);
 }
diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.h b/noncore/net/mail/libmailwrapper/imapwrapper.h
index b246f58..b2bd7e9 100644
--- a/noncore/net/mail/libmailwrapper/imapwrapper.h
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.h
@@ -1,71 +1,73 @@
 #ifndef __IMAPWRAPPER
 #define __IMAPWRAPPER
 
 #include <qlist.h>
 #include "mailwrapper.h"
 #include "abstractmail.h"
 #include <libetpan/clist.h>
 
 struct mailimap;
 struct mailimap_body;
 struct mailimap_body_type_1part;
 struct mailimap_body_type_text;
 struct mailimap_body_type_basic;
 struct mailimap_body_type_msg;
 struct mailimap_body_type_mpart;
 struct mailimap_body_fields;
 struct mailimap_msg_att;
 class encodedString;
 
 class IMAPwrapper : public AbstractMail
 {
     Q_OBJECT
 public:
     IMAPwrapper( IMAPaccount *a );
     virtual ~IMAPwrapper();
     virtual QList<Folder>* listFolders();
     virtual void listMessages(const QString & mailbox,QList<RecMail>&target );
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
     
     virtual void deleteMail(const RecMail&mail);
     virtual void answeredMail(const RecMail&mail);
     virtual int deleteAllMail(const Folder*folder);
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
 
     virtual RecBody fetchBody(const RecMail&mail);
     virtual QString fetchTextPart(const RecMail&mail,const RecPart&part);
     virtual encodedString* fetchDecodedPart(const RecMail&mail,const RecPart&part);
     virtual encodedString* fetchRawPart(const RecMail&mail,const RecPart&part);
     virtual encodedString* fetchRawBody(const RecMail&mail);
 
     virtual int createMbox(const QString&,const Folder*parentfolder=0,const QString& delemiter="/",bool getsubfolder=false);
     virtual int deleteMbox(const Folder*folder);
     
     static void imap_progress( size_t current, size_t maximum );
     
     virtual void logout();
     virtual const QString&getType()const;
+    virtual const QString&getName()const;
+
 protected:
     RecMail*parse_list_result(mailimap_msg_att*);
     void login();
 
     virtual QString fetchTextPart(const RecMail&mail,const QValueList<int>&path,bool internal_call=false,const QString&enc="");
     virtual encodedString*fetchRawPart(const RecMail&mail,const QValueList<int>&path,bool internal_call);
     
     void fillSinglePart(RecPart&target_part,mailimap_body_type_1part*Description);
     void fillSingleTextPart(RecPart&target_part,mailimap_body_type_text*which);
     void fillSingleBasicPart(RecPart&target_part,mailimap_body_type_basic*which);
     void fillSingleMsgPart(RecPart&target_part,mailimap_body_type_msg*which);
     void fillMultiPart(RecPart&target_part,mailimap_body_type_mpart*which);
     void traverseBody(const RecMail&mail,mailimap_body*body,RecBody&target_body,int current_recursion,QValueList<int>recList,int current_count=1);
     
     /* just helpers */
     static void fillBodyFields(RecPart&target_part,mailimap_body_fields*which);
     static QStringList address_list_to_stringlist(clist*list);
 
 
     IMAPaccount *account;
     mailimap *m_imap;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
index bc496f7..97f301e 100644
--- a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
@@ -1,332 +1,337 @@
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <stdlib.h>
 #include <qpe/global.h>
 
 const QString MBOXwrapper::wrapperType="MBOX";
 
-MBOXwrapper::MBOXwrapper(const QString & mbox_dir)
-    : Genericwrapper(),MBOXPath(mbox_dir)
+MBOXwrapper::MBOXwrapper(const QString & mbox_dir,const QString&mbox_name)
+    : Genericwrapper(),MBOXPath(mbox_dir),MBOXName(mbox_name)
 {
     QDir dir(MBOXPath);
     if (!dir.exists()) {
         dir.mkdir(MBOXPath);
     }
 }
     
 MBOXwrapper::~MBOXwrapper()
 {
 }
 
 void MBOXwrapper::listMessages(const QString & mailbox, QList<RecMail> &target )
 {
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mailbox;
     
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error initializing mbox");
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
     
     parseList(target,folder->fld_session,mailbox);
     
     mailfolder_disconnect(folder);
     mailfolder_free(folder);
     mailstorage_free(storage);
     Global::statusMessage(tr("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
 QList<Folder>* MBOXwrapper::listFolders()
 {
     QList<Folder> * folders = new QList<Folder>();
     folders->setAutoDelete( false );
     QDir dir(MBOXPath);
     if (!dir.exists()) return folders;
     dir.setFilter(QDir::Files|QDir::Writable|QDir::Readable);
     QStringList entries = dir.entryList();
     QStringList::ConstIterator it = entries.begin();
     for (;it!=entries.end();++it) {
         Folder*inb=new Folder(*it,"/");
         folders->append(inb);
     }
     return folders;
 }
 
 void MBOXwrapper::deleteMail(const RecMail&mail)
 {
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail.getMbox();
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error initializing mbox");
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
     r = mailsession_remove_message(folder->fld_session,mail.getNumber());
     if (r != MAIL_NO_ERROR) {
         qDebug("error deleting mail");
     }
     mailfolder_free(folder);
     mailstorage_free(storage);
 }
 
 void MBOXwrapper::answeredMail(const RecMail&)
 {
 }
 
 RecBody MBOXwrapper::fetchBody( const RecMail &mail )
 {
     RecBody body;
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail.getMbox();
     mailmessage * msg;
     char*data=0;
     size_t size;
 
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error initializing mbox");
         mailfolder_free(folder);
         mailstorage_free(storage);
         return body;
     }
     r = mailsession_get_message(folder->fld_session, mail.getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error fetching mail %i",mail.getNumber());
         mailfolder_free(folder);
         mailstorage_free(storage);
         return body;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error fetching mail %i",mail.getNumber());
         mailfolder_free(folder);
         mailstorage_free(storage);
         mailmessage_free(msg);
         return body;
     }
     body = parseMail(msg);    
     mailmessage_fetch_result_free(msg,data);
     mailfolder_free(folder);
     mailstorage_free(storage);
     
     return body;
 }
 
 void MBOXwrapper::mbox_progress( size_t current, size_t maximum )
 {
     qDebug("MBOX %i von %i",current,maximum);
 }
 
 int MBOXwrapper::createMbox(const QString&folder,const Folder*,const QString&,bool )
 {
     QString p = MBOXPath+"/";
     p+=folder;
     QFileInfo fi(p);
     if (fi.exists()) {
         Global::statusMessage(tr("Mailbox exists."));
         return 0;
     }
     mailmbox_folder*f = 0;
     if (mailmbox_init(p.latin1(),0,1,0,&f) != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error init folder"));
         return 0;
     }
     if (f) mailmbox_done(f);
     return 1;
 }
 
 void MBOXwrapper::storeMessage(const char*msg,size_t length, const QString&folder)
 {
     QString p = MBOXPath+"/";
     p+=folder;
     mailmbox_folder*f = 0;
     int r = mailmbox_init(p.latin1(),0,1,0,&f);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error init folder"));
         return;
     }
     r = mailmbox_append_message(f,msg,length);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error writing to message folder"));
     }
     mailmbox_done(f);
 }
 
 encodedString* MBOXwrapper::fetchRawBody(const RecMail&mail)
 {
     RecBody body;
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail.getMbox();
     mailmessage * msg;
     char*data=0;
     size_t size;
 
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error initializing mbox"));
         mailfolder_free(folder);
         mailstorage_free(storage);
         return 0;
     }
     r = mailsession_get_message(folder->fld_session, mail.getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error fetching mail %i").arg(mail.getNumber()));
         mailfolder_free(folder);
         mailstorage_free(storage);
         return 0;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error fetching mail %i").arg(mail.getNumber()));
         mailfolder_free(folder);
         mailstorage_free(storage);
         mailmessage_free(msg);
         return 0;
     }
     encodedString*result = new encodedString(data,size);
 
     mailfolder_free(folder);
     mailstorage_free(storage);
     mailmessage_free(msg);
     return result;
 }
 
 void MBOXwrapper::deleteMails(const QString & mailbox,QList<RecMail> &target)
 {
     QString p = MBOXPath+"/";
     p+=mailbox;
     mailmbox_folder*f = 0;
     int r = mailmbox_init(p.latin1(),0,1,0,&f);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error init folder");
         return;
     }
     deleteMails(f,target);
     mailmbox_done(f);
 }
 
 void MBOXwrapper::deleteMails(mailmbox_folder*f,QList<RecMail> &target)
 {
     if (!f) return;
     int r;
     for (unsigned int i=0; i < target.count();++i) {
         r = mailmbox_delete_msg(f,target.at(i)->getNumber());
         if (r!=MAILMBOX_NO_ERROR) {
             qDebug("error delete mail");
         }
     }
     r = mailmbox_expunge(f);
     if (r != MAILMBOX_NO_ERROR) {
         qDebug("error expunge mailbox");
     }
 }
 
 int MBOXwrapper::deleteAllMail(const Folder*tfolder)
 {
     if (!tfolder) return 0;
     QString p = MBOXPath+"/"+tfolder->getDisplayName();
     int res = 1;
     
     mailfolder*folder = 0;
     mailmessage_list*l=0;
     mailstorage*storage = mailstorage_new(NULL);
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error initializing mbox"));
         res = 0;
     }
     if (res) {
         folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
         r = mailfolder_connect(folder);
         if (r != MAIL_NO_ERROR) {
             Global::statusMessage(tr("Error initializing mbox"));
             res = 0;
         }
     }
     if (res) {
         r = mailsession_get_messages_list(folder->fld_session,&l);
         if (r != MAIL_NO_ERROR) {
             qDebug("Error message list");
             res=0;
         }
     }
     for(unsigned int i = 0 ; l!= 0 && res==1 && i < carray_count(l->msg_tab) ; ++i) {
         r = mailsession_remove_message(folder->fld_session,i+1);
         if (r != MAIL_NO_ERROR) {
             Global::statusMessage(tr("Error deleting mail %1").arg(i+1));
             res = 0;
             break;
         }
     }
     if (l) mailmessage_list_free(l);
     if (folder) mailfolder_free(folder);
     if (storage) mailstorage_free(storage);
     return res;
 }
 
 int MBOXwrapper::deleteMbox(const Folder*tfolder)
 {
     if (!tfolder) return 0;
     QString p = MBOXPath+"/"+tfolder->getDisplayName();
     QFile fi(p);
     if (!fi.exists()) {
         Global::statusMessage(tr("Mailbox doesn't exist."));
         return 0;
     }
     if (!fi.remove()) {
         Global::statusMessage(tr("Error deleting Mailbox."));
         return 0;
     }
     return 1;
 }
 
 void MBOXwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     mailfolder*folder = 0;
     mailstorage*storage = mailstorage_new(NULL);
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     QString p = MBOXPath+"/"+mailbox;
     QFile fi(p);
     if (!fi.exists()) {
         Global::statusMessage(tr("Mailbox doesn't exist."));
         return;
     }
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);   
     r = mailfolder_connect(folder);
     r = mailsession_status_folder(folder->fld_session,(char*)mailbox.latin1(),&target_stat.message_count,
         &target_stat.message_recent,&target_stat.message_unseen);
     if (folder) mailfolder_free(folder);
     if (storage) mailstorage_free(storage);
 }
 
 const QString&MBOXwrapper::getType()const
 {
     return wrapperType;
 }
+
+const QString&MBOXwrapper::getName()const
+{
+    return MBOXName;
+}
diff --git a/noncore/net/mail/libmailwrapper/mboxwrapper.h b/noncore/net/mail/libmailwrapper/mboxwrapper.h
index 2794014..194ff86 100644
--- a/noncore/net/mail/libmailwrapper/mboxwrapper.h
+++ b/noncore/net/mail/libmailwrapper/mboxwrapper.h
@@ -1,45 +1,47 @@
 #ifndef __MBOX_WRAPPER_H
 #define __MBOX_WRAPPER_H
 
 #include "genericwrapper.h"
 #include <qstring.h>
 
 class RecMail;
 class RecBody;
 class encodedString;
 struct mailmbox_folder;
 
 class MBOXwrapper : public Genericwrapper
 {
     Q_OBJECT
 public:
-    MBOXwrapper(const QString & dir);
+    MBOXwrapper(const QString & dir,const QString&name);
     virtual ~MBOXwrapper();
     
     virtual void listMessages(const QString & mailbox, QList<RecMail> &target );
     virtual QList<Folder>* listFolders();
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMail&mail);
     virtual void answeredMail(const RecMail&mail);
     
     virtual int createMbox(const QString&folder,const Folder*f=0,const QString&d="",bool s=false);
     virtual int deleteMbox(const Folder*);
 
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
 
     virtual RecBody fetchBody( const RecMail &mail );
     static void mbox_progress( size_t current, size_t maximum );
 
     virtual encodedString* fetchRawBody(const RecMail&mail);
-    virtual void deleteMails(const QString & mailbox,QList<RecMail> &target);
+    virtual void deleteMails(const QString & FolderName,QList<RecMail> &target);
     virtual int deleteAllMail(const Folder*);
     virtual const QString&getType()const;
+    virtual const QString&getName()const;
 
 protected:
     static void deleteMails(mailmbox_folder*f,QList<RecMail> &target);
     QString MBOXPath;
+    QString MBOXName;
     static const QString wrapperType;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
index cceb22e..67bde38 100644
--- a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
@@ -1,251 +1,257 @@
 #include <stdlib.h>
 #include "pop3wrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 #include <libetpan/libetpan.h>
 #include <qpe/global.h>
 #include <qfile.h>
 #include <qstring.h>
 
 /* we don't fetch messages larger than 5 MB */
 #define HARD_MSG_SIZE_LIMIT 5242880
 
 POP3wrapper::POP3wrapper( POP3account *a )
     : Genericwrapper()
 {
     account = a;
     m_pop3 = NULL;
     m_folder = NULL;
     msgTempName = a->getFileName()+"_msg_cache";
     last_msg_id = 0;
 }
 
 POP3wrapper::~POP3wrapper()
 {
     logout();
     QFile msg_cache(msgTempName);
     if (msg_cache.exists()) {
         msg_cache.remove();
     }
 }
 
 void POP3wrapper::pop3_progress( size_t current, size_t maximum )
 {
     qDebug( "POP3: %i of %i", current, maximum );
 }
 
 RecBody POP3wrapper::fetchBody( const RecMail &mail )
 {
     int err = MAILPOP3_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     login();
     if ( !m_pop3 ) {
         return RecBody();
     }
 
     RecBody body;
     mailmessage * mailmsg;
     if (mail.Msgsize()>HARD_MSG_SIZE_LIMIT) {
         qDebug("Message to large: %i",mail.Msgsize());
         return body;
     }
 
     QFile msg_cache(msgTempName);
 
     cleanMimeCache();
 
     if (mail.getNumber()!=last_msg_id) {
         if (msg_cache.exists()) {
             msg_cache.remove();
         }
         msg_cache.open(IO_ReadWrite|IO_Truncate);
         last_msg_id = mail.getNumber();
         err = mailsession_get_message(m_folder->fld_session, mail.getNumber(), &mailmsg);
         err = mailmessage_fetch(mailmsg,&message,&length);
         msg_cache.writeBlock(message,length);
     } else {
         QString msg="";
         msg_cache.open(IO_ReadOnly);
         message = new char[4096];
         memset(message,0,4096);
         while (msg_cache.readBlock(message,4095)>0) {
             msg+=message;
             memset(message,0,4096);
         }
         delete message;
         message = (char*)malloc(msg.length()+1*sizeof(char));
         memset(message,0,msg.length()+1);
         memcpy(message,msg.latin1(),msg.length());
         /* transform to libetpan stuff */
         mailmsg = mailmessage_new();
         mailmessage_init(mailmsg, NULL, data_message_driver, 0, strlen(message));
         generic_message_t * msg_data;
         msg_data = (generic_message_t *)mailmsg->msg_data;
         msg_data->msg_fetched = 1;
         msg_data->msg_message = message;
         msg_data->msg_length = strlen(message);
     }
     body = parseMail(mailmsg);
 
     /* clean up */
     if (mailmsg) mailmessage_free(mailmsg);
     if (message) free(message);
 
     return body;
 }
 
 void POP3wrapper::listMessages(const QString &, QList<RecMail> &target )
 {
     login();
     if (!m_pop3) return;
     uint32_t res_messages,res_recent,res_unseen;
     mailsession_status_folder(m_folder->fld_session,"INBOX",&res_messages,&res_recent,&res_unseen);
     parseList(target,m_folder->fld_session,"INBOX");
     Global::statusMessage( tr("Mailbox contains %1 mail(s)").arg(res_messages));
 }
 
 void POP3wrapper::login()
 {
+    if (account->getOffline()) return;
     /* we'll hold the line */
     if ( m_pop3 != NULL ) return;
 
     const char *server, *user, *pass;
     uint16_t port;
     int err = MAILPOP3_NO_ERROR;
 
     server = account->getServer().latin1();
     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().latin1();
                 pass = login.getPassword().latin1();
           } else {
                 // cancel
                 qDebug( "POP3: Login canceled" );
                 return;
           }
         } else {
           user = account->getUser().latin1();
           pass = account->getPassword().latin1();
         }
 
     bool ssl = account->getSSL();
 
     m_pop3=mailstorage_new(NULL);
     int conntype = (ssl?CONNECTION_TYPE_TLS:CONNECTION_TYPE_PLAIN);
     
     pop3_mailstorage_init(m_pop3,(char*)server,port,NULL,conntype,POP3_AUTH_TYPE_PLAIN,
         (char*)user,(char*)pass,0,0,0);
 
     m_folder = mailfolder_new(m_pop3, NULL, NULL);
 
     if (m_folder==0) {
         Global::statusMessage(tr("Error initializing folder"));
         mailstorage_free(m_pop3);
         m_pop3 = NULL;
         return;
     }
     err = mailfolder_connect(m_folder);
     if (err != MAIL_NO_ERROR) {
         qDebug( QString( "FEHLERNUMMER %1" ).arg(  err ) );
         Global::statusMessage(tr("Error initializing folder"));
         mailfolder_free(m_folder);
         m_folder = 0;
         mailstorage_free(m_pop3);
         m_pop3 = 0;
     }
 }
 
 void POP3wrapper::logout()
 {
     int err = MAILPOP3_NO_ERROR;
     if ( m_pop3 == NULL ) return;
     mailfolder_free(m_folder);
     m_folder = 0;
     mailstorage_free(m_pop3);
     m_pop3 = 0;
 }
 
 
 QList<Folder>* POP3wrapper::listFolders()
 {
     QList<Folder> * folders = new QList<Folder>();
     folders->setAutoDelete( false );
     Folder*inb=new Folder("INBOX","/");
     folders->append(inb);
     return folders;
 }
 
 void POP3wrapper::deleteMail(const RecMail&mail)
 {
     login();
     if (!m_pop3) return;
     int err = mailsession_remove_message(m_folder->fld_session,mail.getNumber());
     if (err != MAIL_NO_ERROR) {
         Global::statusMessage(tr("error deleting mail"));
     }
 }
 
 void POP3wrapper::answeredMail(const RecMail&)
 {
 }
 
 int POP3wrapper::deleteAllMail(const Folder*)
 {
     login();
     if (!m_pop3) return 0;
     int res = 1;
 
     uint32_t result = 0;
     int err = mailsession_messages_number(m_folder->fld_session,NULL,&result);
     if (err != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error getting folder info"));
         return 0;
     }
     for (unsigned int i = 0; i < result; ++i) {
         err = mailsession_remove_message(m_folder->fld_session,i+1);
         if (err != MAIL_NO_ERROR) {
             Global::statusMessage(tr("Error deleting mail %1").arg(i+1));
             res=0;
         }
         break;
     }
     return res;
 }
 
 void POP3wrapper::statusFolder(folderStat&target_stat,const QString&)
 {
     login();
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     if (!m_pop3) return;
     int r = mailsession_status_folder(m_folder->fld_session,0,&target_stat.message_count,
         &target_stat.message_recent,&target_stat.message_unseen);
 }
 
 encodedString* POP3wrapper::fetchRawBody(const RecMail&mail)
 {
     char*target=0;
     size_t length=0;
     encodedString*res = 0;
     mailmessage * mailmsg = 0;
     int err = mailsession_get_message(m_folder->fld_session, mail.getNumber(), &mailmsg);
     err = mailmessage_fetch(mailmsg,&target,&length);
     if (mailmsg) mailmessage_free(mailmsg);
     if (target) {
         res = new encodedString(target,length);
     }
     return res;
 }
 
 const QString&POP3wrapper::getType()const
 {
     return account->getType();
 }
+
+const QString&POP3wrapper::getName()const
+{
+    return account->getAccountName();
+}
diff --git a/noncore/net/mail/libmailwrapper/pop3wrapper.h b/noncore/net/mail/libmailwrapper/pop3wrapper.h
index f0307b6..d2b708d 100644
--- a/noncore/net/mail/libmailwrapper/pop3wrapper.h
+++ b/noncore/net/mail/libmailwrapper/pop3wrapper.h
@@ -1,42 +1,43 @@
 #ifndef __POP3WRAPPER
 #define __POP3WRAPPER
 
 #include "mailwrapper.h"
 #include "genericwrapper.h"
 #include <qstring.h>
 
 class encodedString;
 struct mailstorage;
 struct mailfolder;
 
 class POP3wrapper : public Genericwrapper
 {
     Q_OBJECT
 
 public:
     POP3wrapper( POP3account *a );
     virtual ~POP3wrapper();
     /* mailbox will be ignored */
     virtual void listMessages(const QString & mailbox, QList<RecMail> &target );
     virtual QList<Folder>* listFolders();
     /* mailbox will be ignored */
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMail&mail);
     virtual void answeredMail(const RecMail&mail);
     virtual int deleteAllMail(const Folder*);
 
     virtual RecBody fetchBody( const RecMail &mail );
     virtual encodedString* fetchRawBody(const RecMail&mail);
     virtual void logout();
     virtual const QString&getType()const;
+    virtual const QString&getName()const;
     static void pop3_progress( size_t current, size_t maximum );
 
 protected:
     void login();
     POP3account *account;
     mailstorage*m_pop3;
     mailfolder*m_folder;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/settings.cpp b/noncore/net/mail/libmailwrapper/settings.cpp
index c5187f5..02a80a3 100644
--- a/noncore/net/mail/libmailwrapper/settings.cpp
+++ b/noncore/net/mail/libmailwrapper/settings.cpp
@@ -1,413 +1,425 @@
 #include <stdlib.h>
 #include <qdir.h>
 
 #include <qpe/config.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()
 {
    updateAccounts();
 }
 
 void Settings::checkDirectory()
 {
     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( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
     QStringList::Iterator it;
 
     QStringList imap = dir.entryList( "imap-*" );
     for ( it = imap.begin(); it != imap.end(); it++ ) {
         qDebug( "Added IMAP account" );
         IMAPaccount *account = new IMAPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList pop3 = dir.entryList( "pop3-*" );
     for ( it = pop3.begin(); it != pop3.end(); it++ ) {
         qDebug( "Added POP account" );
         POP3account *account = new POP3account( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList smtp = dir.entryList( "smtp-*" );
     for ( it = smtp.begin(); it != smtp.end(); it++ ) {
         qDebug( "Added SMTP account" );
         SMTPaccount *account = new SMTPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList nntp = dir.entryList( "nntp-*" );
     for ( it = nntp.begin(); it != nntp.end(); it++ ) {
         qDebug( "Added NNTP account" );
         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 = "changeMe";
     ssl = false;
 }
 
 void Account::remove()
 {
     QFile file( getFileName() );
     file.remove();
 }
 
 IMAPaccount::IMAPaccount()
     : Account()
 {
     file = IMAPaccount::getUniqueFileName();
     accountName = "New IMAP Account";
     ssl = false;
     type = "IMAP";
     port = IMAP_PORT;
 }
 
 IMAPaccount::IMAPaccount( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New IMAP Account";
     ssl = false;
     type = "IMAP";
     port = IMAP_PORT;
 }
 
 QString IMAPaccount::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
 
     QStringList imap = dir.entryList( "imap-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "imap-" + unique ) > 0 );
 
     return unique;
 }
 
 void IMAPaccount::read()
 {
     Config *conf = new Config( getFileName(), Config::File );
     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";
     ssl = conf->readBoolEntry( "SSL",false );
     user = conf->readEntry( "User","" );
     if (user.isNull()) user = "";
     password = conf->readEntryCrypt( "Password","" );
     if (password.isNull()) password = "";
     prefix = conf->readEntry("MailPrefix","");
     if (prefix.isNull()) prefix = "";
+    offline = conf->readBoolEntry("Offline",false);
+    delete conf;
 }
 
 void IMAPaccount::save()
 {
     qDebug( "saving " + getFileName() );
     Settings::checkDirectory();
 
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "IMAP Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "User", user );
     conf->writeEntryCrypt( "Password", password );
     conf->writeEntry( "MailPrefix",prefix);
+    conf->writeEntry( "Offline",offline);
     conf->write();
+    delete conf;
 }
 
 
 QString IMAPaccount::getFileName()
 {
     return (QString) getenv( "HOME" ) + "/Applications/opiemail/imap-" + file;
 }
 
 POP3account::POP3account()
     : Account()
 {
     file = POP3account::getUniqueFileName();
     accountName = "New POP3 Account";
     ssl = false;
     type = "POP3";
     port = POP3_PORT;
 }
 
 POP3account::POP3account( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New POP3 Account";
     ssl = false;
     type = "POP3";
     port = POP3_PORT;
 }
 
 QString POP3account::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
 
     QStringList imap = dir.entryList( "pop3-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "pop3-" + unique ) > 0 );
 
     return unique;
 }
 
 void POP3account::read()
 {
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "POP3 Account" );
     accountName = conf->readEntry( "Account" );
     server = conf->readEntry( "Server" );
     port = conf->readEntry( "Port" );
     ssl = conf->readBoolEntry( "SSL" );
     user = conf->readEntry( "User" );
     password = conf->readEntryCrypt( "Password" );
+    offline = conf->readBoolEntry("Offline",false);
+    delete conf;
 }
 
 void POP3account::save()
 {
     qDebug( "saving " + getFileName() );
     Settings::checkDirectory();
 
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "POP3 Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "User", user );
     conf->writeEntryCrypt( "Password", password );
+    conf->writeEntry( "Offline",offline);
     conf->write();
+    delete conf;
 }
 
 
 QString POP3account::getFileName()
 {
     return (QString) getenv( "HOME" ) + "/Applications/opiemail/pop3-" + file;
 }
 
 SMTPaccount::SMTPaccount()
     : Account()
 {
     file = SMTPaccount::getUniqueFileName();
     accountName = "New SMTP Account";
     ssl = false;
     login = false;
     useCC = false;
     useBCC = false;
     useReply = false;
     type = "SMTP";
     port = SMTP_PORT;
 }
 
 SMTPaccount::SMTPaccount( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New SMTP Account";
     ssl = false;
     login = false;
     type = "SMTP";
     port = SMTP_PORT;
 }
 
 QString SMTPaccount::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
 
     QStringList imap = dir.entryList( "smtp-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "smtp-" + unique ) > 0 );
 
     return unique;
 }
 
 void SMTPaccount::read()
 {
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "SMTP Account" );
     accountName = conf->readEntry( "Account" );
     server = conf->readEntry( "Server" );
     port = conf->readEntry( "Port" );
     ssl = conf->readBoolEntry( "SSL" );
     login = conf->readBoolEntry( "Login" );
     user = conf->readEntry( "User" );
     password = conf->readEntryCrypt( "Password" );
+    delete conf;
 }
 
 void SMTPaccount::save()
 {
     qDebug( "saving " + getFileName() );
     Settings::checkDirectory();
 
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "SMTP Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "Login", login );
     conf->writeEntry( "User", user );
     conf->writeEntryCrypt( "Password", password );
     conf->write();
+    delete conf;
 }
 
 
 QString SMTPaccount::getFileName()
 {
     return (QString) getenv( "HOME" ) + "/Applications/opiemail/smtp-" + file;
 }
 
 NNTPaccount::NNTPaccount()
     : Account()
 {
     file = NNTPaccount::getUniqueFileName();
     accountName = "New NNTP Account";
     ssl = false;
     login = false;
     type = "NNTP";
     port = NNTP_PORT;
 }
 
 NNTPaccount::NNTPaccount( QString filename )
     : Account()
 {
     file = filename;
     accountName = "New NNTP Account";
     ssl = false;
     login = false;
     type = "NNTP";
     port = NNTP_PORT;
 }
 
 QString NNTPaccount::getUniqueFileName()
 {
     int num = 0;
     QString unique;
 
     QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
 
     QStringList imap = dir.entryList( "nntp-*" );
     do {
         unique.setNum( num++ );
     } while ( imap.contains( "nntp-" + unique ) > 0 );
 
     return unique;
 }
 
 void NNTPaccount::read()
 {
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "NNTP Account" );
     accountName = conf->readEntry( "Account" );
     server = conf->readEntry( "Server" );
     port = conf->readEntry( "Port" );
     ssl = conf->readBoolEntry( "SSL" );
     login = conf->readBoolEntry( "Login" );
     user = conf->readEntry( "User" );
     password = conf->readEntryCrypt( "Password" );
+    delete conf;
 }
 
 void NNTPaccount::save()
 {
     qDebug( "saving " + getFileName() );
     Settings::checkDirectory();
 
     Config *conf = new Config( getFileName(), Config::File );
     conf->setGroup( "NNTP Account" );
     conf->writeEntry( "Account", accountName );
     conf->writeEntry( "Server", server );
     conf->writeEntry( "Port", port );
     conf->writeEntry( "SSL", ssl );
     conf->writeEntry( "Login", login );
     conf->writeEntry( "User", user );
     conf->writeEntryCrypt( "Password", password );
     conf->write();
+    delete conf;
 }
 
 
 QString NNTPaccount::getFileName()
 {
     return (QString) getenv( "HOME" ) + "/Applications/opiemail/nntp-" + file;
 }
 
diff --git a/noncore/net/mail/libmailwrapper/settings.h b/noncore/net/mail/libmailwrapper/settings.h
index caa5dfc..2104997 100644
--- a/noncore/net/mail/libmailwrapper/settings.h
+++ b/noncore/net/mail/libmailwrapper/settings.h
@@ -1,146 +1,149 @@
 #ifndef SETTINGS_H
 #define SETTINGS_H
 
 #include <qobject.h>
 #include <qlist.h>
 
 class Account 
 {
     
 public:
     Account();
     virtual ~Account() {}
 
     void remove();
     void setAccountName( QString name ) { accountName = name; }
     const QString&getAccountName()const{ return accountName; }
     const QString&getType()const{ return type; }
     
     void setServer(const QString&str){ server = str; }
     const QString&getServer()const{ return server; }
     
     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 setSSL( bool b ) { ssl = b; }
     bool getSSL() { return ssl; }
+    
+    void setOffline(bool b) {offline = b;}
+    bool getOffline()const{return offline;}
 
     virtual QString getFileName() { return accountName; }
     virtual void read() { qDebug( "base reading..." ); }
     virtual void save() { qDebug( "base saving..." ); }
 
 protected:
     QString accountName, type, server, port, user, password;
     bool ssl;
-    
+    bool offline;
 };
 
 class IMAPaccount : public Account
 {
         
 public:
     IMAPaccount();
     IMAPaccount( QString filename );
 
     static QString getUniqueFileName();
 
     virtual void read();
     virtual void save();
     virtual QString getFileName();
 
     void setPrefix(const QString&str) {prefix=str;}
     const QString&getPrefix()const{return prefix;}
 
 private:
     QString file,prefix;
 
 };
 
 class POP3account : public Account
 {
         
 public:
     POP3account();
     POP3account( QString filename );
 
     static QString getUniqueFileName();
 
     virtual void read();
     virtual void save();
     virtual QString getFileName();
 
 private:
     QString file;
     
 };
 
 class SMTPaccount : public Account
 {
     
 public:
     SMTPaccount();
     SMTPaccount( QString filename );
 
     static QString getUniqueFileName();
 
     virtual void read();
     virtual void save();
     virtual QString getFileName();
 
     void setLogin( bool b ) { login = b; }
     bool getLogin() { return login; }
 
 private:
     QString file, name, mail, org, cc, bcc, reply, signature;
     bool useCC, useBCC, useReply, login;
 
 };
 
 class NNTPaccount : public Account
 {
         
 public:
     NNTPaccount();
     NNTPaccount( QString filename );
 
     static QString getUniqueFileName();
 
     virtual void read();
     virtual void save();
     virtual QString getFileName();
 
     void setLogin( bool b ) { login = b; }
     bool getLogin() { return login; }
 
 private:
     QString file;
     bool login;
 
 };
 
 class Settings : public QObject
 {
     Q_OBJECT
 
 public:
     Settings();
     QList<Account> getAccounts();
     void addAccount(Account *account);
     void delAccount(Account *account);
     void saveAccounts();
     void readAccounts();
     static void checkDirectory();
 
 private:
     void updateAccounts();
     QList<Account> accounts;
         
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
index 4764b77..281b88e 100644
--- a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
@@ -300,430 +300,428 @@ mailmime *SMTPwrapper::buildFilePart(const QString&filename,const QString&mimety
             qDebug("Error setting body with file %s",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 SMTPwrapper::addFileParts( mailmime *message,const QList<Attachment>&files )
 {
     const Attachment *it;
     unsigned int count = files.count();
     qDebug("List contains %i values",count);
     for ( unsigned int i = 0; i < count; ++i ) {
         qDebug( "Adding file" );
         mailmime *filePart;
         int err;
         it = ((QList<Attachment>)files).at(i);
 
         filePart = buildFilePart( it->getFileName(), it->getMimeType(),"" );
         if ( filePart == NULL ) {
             qDebug( "addFileParts: error adding file:" );
             qDebug( it->getFileName() );
             continue;
         }
         err = mailmime_smart_add_part( message, filePart );
         if ( err != MAILIMF_NO_ERROR ) {
             mailmime_free( filePart );
             qDebug("error smart add");
         }
     }
 }
 
 mailmime *SMTPwrapper::createMimeMail(const 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:
     qDebug( "createMimeMail: error" );
 
     return NULL;            // Error :(
 }
 
 mailimf_field *SMTPwrapper::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;
 }
 
 void SMTPwrapper::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 );
                 }
             }
     }
 }
 
 clist *SMTPwrapper::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;
 }
 
 char *SMTPwrapper::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 *SMTPwrapper::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);
 }
 
 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();
-    MBOXwrapper*wrap = new MBOXwrapper(localfolders);
+    AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     wrap->storeMessage(mail,length,box);
     delete wrap;
 }
 
 void SMTPwrapper::smtpSend( mailmime *mail,bool later, SMTPaccount *smtp )
 {
     clist *rcpts = 0;
     char *from, *data;
     size_t size;
 
     if ( smtp == NULL ) {
         return;
     }
     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;
     }
-    QString tmp = data;
-    tmp.replace(QRegExp("\r+",true,false),"");
     msg = 0;
     if (later) {
-        storeMail((char*)tmp.data(),tmp.length(),"Outgoing");
+        storeMail(data,size,"Outgoing");
         if (data) free( data );
         Config cfg( "mail" );
         cfg.setGroup( "Status" );
         cfg.writeEntry( "outgoing", ++m_queuedMail );
         emit queuedMails( m_queuedMail );
         return;
     }
     from = getFrom( mail );
     rcpts = createRcptList( mail->mm_data.mm_message.mm_fields );
     smtpSend(from,rcpts,data,size,smtp);
     if (data) {free(data);}
     if (from) {free(from);}
     if (rcpts) smtp_address_list_free( rcpts );
 }
 
 int SMTPwrapper::smtpSend(char*from,clist*rcpts,const char*data,size_t size, SMTPaccount *smtp )
 {
     const char *server, *user, *pass;
     bool ssl;
     uint16_t port;
     mailsmtp *session;
     int err,result;
 
     result = 1;
     server = user = pass = 0;
     server = smtp->getServer().latin1();
     ssl = smtp->getSSL();
     port = smtp->getPort().toUInt();
 
     session = mailsmtp_new( 20, &progress );
     if ( session == NULL ) goto free_mem;
 
     qDebug( "Servername %s at port %i", server, port );
     if ( ssl ) {
         qDebug( "SSL session" );
         err = mailsmtp_ssl_connect( session, server, port );
     } else {
         qDebug( "No SSL session" );
         err = mailsmtp_socket_connect( session, server, port );
     }
     if ( err != MAILSMTP_NO_ERROR ) {qDebug("Error init connection");result = 0;goto free_mem_session;}
 
     err = mailsmtp_init( session );
     if ( err != MAILSMTP_NO_ERROR ) {result = 0; goto free_con_session;}
 
     qDebug( "INIT OK" );
 
     if ( smtp->getLogin() ) {
         qDebug("smtp with auth");
         if ( smtp->getUser().isEmpty() || smtp->getPassword().isEmpty() ) {
             // get'em
             LoginDialog login( smtp->getUser(), smtp->getPassword(), NULL, 0, true );
             login.show();
             if ( QDialog::Accepted == login.exec() ) {
                 // ok
                 user = login.getUser().latin1();
                 pass = login.getPassword().latin1();
             } else {
                 result = 0; goto free_con_session;
             }
         } else {
             user = smtp->getUser().latin1();
             pass = smtp->getPassword().latin1();
         }
         qDebug( "session->auth: %i", session->auth);
         err = mailsmtp_auth( session, (char*)user, (char*)pass );
         if ( err == MAILSMTP_NO_ERROR ) qDebug("auth ok");
         qDebug( "Done auth!" );
     } else {
         qDebug("SMTP without auth");
     }
 
     err = mailsmtp_send( session, from, rcpts, data, size );
     if ( err != MAILSMTP_NO_ERROR ) {
         qDebug("Error sending mail: %s",mailsmtpError(err).latin1());
         result = 0; goto free_con_session;
     }
 
     qDebug( "Mail sent." );
     storeMail(data,size,"Sent");
 
 free_con_session:
     mailsmtp_quit( session );
 free_mem_session:
     mailsmtp_free( session );
 free_mem:
     return result;
 }
 
 void SMTPwrapper::sendMail(const Mail&mail,SMTPaccount*aSmtp,bool later )
 {
     mailmime * mimeMail;
 
     SMTPaccount *smtp = aSmtp;
 
     if (!later && !smtp) {
         qDebug("Didn't get any send method - giving up");
         return;
     }
     mimeMail = createMimeMail(mail );
     if ( mimeMail == NULL ) {
         qDebug( "sendMail: error creating mime mail" );
     } else {
         sendProgress = new progressMailSend();
         sendProgress->show();
         sendProgress->setMaxMails(1);
         smtpSend( mimeMail,later,smtp);
         qDebug("Clean up done");
         sendProgress->hide();
         delete sendProgress;
         sendProgress = 0;
         mailmime_free( mimeMail );
     }
 }
 
-int SMTPwrapper::sendQueuedMail(MBOXwrapper*wrap,SMTPaccount*smtp,RecMail*which)
+int SMTPwrapper::sendQueuedMail(AbstractMail*wrap,SMTPaccount*smtp,RecMail*which)
 {
     size_t curTok = 0;
     mailimf_fields *fields = 0;
     mailimf_field*ffrom = 0;
     clist *rcpts = 0;
     char*from = 0;
     int res = 0;
 
     encodedString * data = wrap->fetchRawBody(*which);
     if (!data) return 0;
     int err = mailimf_fields_parse( data->Content(), data->Length(), &curTok, &fields );
     if (err != MAILIMF_NO_ERROR) {
         delete data;
         delete wrap;
         return 0;
     }
 
     rcpts = createRcptList( fields );
     ffrom = getField(fields, MAILIMF_FIELD_FROM );
     from = getFrom(ffrom);
 
     if (rcpts && from) {
         res = smtpSend(from,rcpts,data->Content(),data->Length(),smtp );
     }
     if (fields) {
         mailimf_fields_free(fields);
         fields = 0;
     }
     if (data) {
         delete data;
     }
     if (from) {
         free(from);
     }
     if (rcpts) {
         smtp_address_list_free( rcpts );
     }
     return res;
 }
 
 /* this is a special fun */
 bool SMTPwrapper::flushOutbox(SMTPaccount*smtp)
 {
     bool returnValue = true;
 
     if (!smtp) return false;
 
     QString localfolders = AbstractMail::defaultLocalfolder();
-    MBOXwrapper*wrap = new MBOXwrapper(localfolders);
+    AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     if (!wrap) {
         qDebug("memory error");
         return false;
     }
     QList<RecMail> mailsToSend;
     QList<RecMail> mailsToRemove;
     QString mbox("Outgoing");
     wrap->listMessages(mbox,mailsToSend);
     if (mailsToSend.count()==0) {
         delete wrap;
         return false;
     }
     mailsToSend.setAutoDelete(false);
     sendProgress = new progressMailSend();
     sendProgress->show();
     sendProgress->setMaxMails(mailsToSend.count());
 
     while (mailsToSend.count()>0) {
         if (sendQueuedMail(wrap,smtp,mailsToSend.at(0))==0) {
             QMessageBox::critical(0,tr("Error sending mail"),
                 tr("Error sending queued mail - breaking"));
             returnValue = false;
             break;
         }
         mailsToRemove.append(mailsToSend.at(0));
         mailsToSend.removeFirst();
         sendProgress->setCurrentMails(mailsToRemove.count());
     }
     Config cfg( "mail" );
     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);
     mailsToSend.setAutoDelete(true);
     delete wrap;
     return returnValue;
 }
diff --git a/noncore/net/mail/libmailwrapper/smtpwrapper.h b/noncore/net/mail/libmailwrapper/smtpwrapper.h
index 04fc4b0..7dcdbfd 100644
--- a/noncore/net/mail/libmailwrapper/smtpwrapper.h
+++ b/noncore/net/mail/libmailwrapper/smtpwrapper.h
@@ -1,72 +1,72 @@
 #ifndef SMTPwrapper_H
 #define SMTPwrapper_H
 
 #include <qpe/applnk.h>
 
 #include <qbitarray.h>
 #include <qdatetime.h>
 #include <libetpan/clist.h>
 
 #include "settings.h"
 
 class Mail;
-class MBOXwrapper;
+class AbstractMail;
 class RecMail;
 class Attachment;
 struct mailimf_fields;
 struct mailimf_field;
 struct mailimf_mailbox;
 struct mailmime;
 struct mailimf_address_list;
 class progressMailSend;
 
 class SMTPwrapper : public QObject
 {
     Q_OBJECT
 
 public:
     SMTPwrapper( Settings *s ); 
     virtual ~SMTPwrapper(){}
     void sendMail(const Mail& mail,SMTPaccount*smtp,bool later=false );
     bool flushOutbox(SMTPaccount*smtp);
 
     static progressMailSend*sendProgress;
 
 signals:
     void queuedMails( int );  
 
 protected:
     mailimf_mailbox *newMailbox(const QString&name,const QString&mail );
     mailimf_fields *createImfFields(const Mail &mail );
     mailmime *createMimeMail(const Mail&mail );
     
     mailimf_address_list *parseAddresses(const QString&addr );
     void addFileParts( mailmime *message,const QList<Attachment>&files );
     mailmime *buildTxtPart(const QString&str );
     mailmime *buildFilePart(const QString&filename,const QString&mimetype,const QString&content);
     void smtpSend( mailmime *mail,bool later, SMTPaccount *smtp );
     clist *createRcptList( mailimf_fields *fields );
     
     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 );
     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 );
     int smtpSend(char*from,clist*rcpts,const char*data,size_t size, SMTPaccount *smtp );
 
     void storeMail(mailmime*mail, const QString&box);
     Settings *settings;
     
-    int sendQueuedMail(MBOXwrapper*wrap,SMTPaccount*smtp,RecMail*which);
+    int sendQueuedMail(AbstractMail*wrap,SMTPaccount*smtp,RecMail*which);
 
     int m_queuedMail;
     static const char* USER_AGENT;
 
 protected slots:
    void emitQCop( int queued );
 
 };
 
 #endif
diff --git a/noncore/net/mail/selectstore.cpp b/noncore/net/mail/selectstore.cpp
index 28ab5a8..0a07d51 100644
--- a/noncore/net/mail/selectstore.cpp
+++ b/noncore/net/mail/selectstore.cpp
@@ -1,19 +1,70 @@
 #include "selectstore.h"
+#include <qlineedit.h>
+#include <qcheckbox.h>
+#include <qcombobox.h>
+#include <libmailwrapper/abstractmail.h>
 
 Selectstore::Selectstore(QWidget* parent, const char* name)
     :selectstoreui(parent,name,true)
 {
-
+    folderMap.clear();
+    mailMap.clear();
+    cMail = 0;
 }
 
 Selectstore::~Selectstore()
 {
 }
 
 void Selectstore::slotCreateNewFolder()
 {
+    bool how = newFoldersel->isChecked();
+    folderSelection->setEnabled(!how);
+    newFolderedit->setEnabled(how);
 }
 
 void Selectstore::slotMoveMail()
 {
 }
+
+void Selectstore::addAccounts(AbstractMail*mail,const QStringList&folders)
+{
+    accountSelection->insertItem(mail->getName());
+    mailMap[accountSelection->count()-1]=mail;
+    folderMap[accountSelection->count()-1]=folders;
+    if (accountSelection->count()==1) {
+        cMail = mail;
+        folderSelection->insertStringList(folders);
+    }
+}
+
+void Selectstore::slotAccountselected(int i)
+{
+    folderSelection->clear();
+    folderSelection->insertStringList(folderMap[i]);
+    cMail = mailMap[i];
+}
+
+QString Selectstore::currentFolder()
+{
+    if (newFoldersel->isChecked()) {
+        return newFolderedit->text();
+    } else {
+        return folderSelection->currentText();
+    }
+}
+
+AbstractMail*Selectstore::currentMail()
+{
+    return cMail;
+}
+
+bool Selectstore::newFolder()
+{
+    return newFoldersel->isChecked();
+}
+
+bool Selectstore::moveMails()
+{
+    return selMove->isChecked();
+}
diff --git a/noncore/net/mail/selectstore.h b/noncore/net/mail/selectstore.h
index 8b8e8ee..447a6ae 100644
--- a/noncore/net/mail/selectstore.h
+++ b/noncore/net/mail/selectstore.h
@@ -1,19 +1,33 @@
 #ifndef _SELECTSTORE_H
 #define _SELECTSTORE_H
 
 #include "selectstoreui.h"
+#include <qvaluelist.h>
+#include <qmap.h>
+#include <qstringlist.h>
+
+class AbstractMail;
 
 class Selectstore:public selectstoreui
 {
     Q_OBJECT
 public:
     Selectstore(QWidget* parent = 0, const char* name = 0);
     virtual ~Selectstore();
+    virtual void addAccounts(AbstractMail*mail,const QStringList&folders);
+    virtual QString currentFolder();
+    virtual AbstractMail*currentMail();
+    bool newFolder();
+    bool moveMails();
 
-protected:
+protected slots:
     virtual void slotCreateNewFolder();
     virtual void slotMoveMail();
-protected slots:
+    virtual void slotAccountselected(int);
 
+protected:
+    QMap<int,QStringList> folderMap;
+    QMap<int,AbstractMail*> mailMap;
+    AbstractMail*cMail;
 };
 #endif
diff --git a/noncore/net/mail/selectstoreui.ui b/noncore/net/mail/selectstoreui.ui
index 3741b71..5f0e507 100644
--- a/noncore/net/mail/selectstoreui.ui
+++ b/noncore/net/mail/selectstoreui.ui
@@ -1,244 +1,279 @@
 <!DOCTYPE UI><UI>
 <class>selectstoreui</class>
 <widget>
     <class>QDialog</class>
     <property stdset="1">
         <name>name</name>
         <cstring>selectstoreui</cstring>
     </property>
     <property stdset="1">
         <name>geometry</name>
         <rect>
             <x>0</x>
             <y>0</y>
-            <width>190</width>
+            <width>182</width>
             <height>273</height>
         </rect>
     </property>
     <property stdset="1">
         <name>caption</name>
         <string>Select target box</string>
     </property>
     <property>
         <name>layoutMargin</name>
     </property>
     <property>
         <name>layoutSpacing</name>
     </property>
     <vbox>
         <property stdset="1">
             <name>margin</name>
-            <number>2</number>
+            <number>1</number>
         </property>
         <property stdset="1">
             <name>spacing</name>
-            <number>2</number>
+            <number>1</number>
         </property>
         <widget>
             <class>QLabel</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>headlabel</cstring>
             </property>
             <property stdset="1">
                 <name>text</name>
                 <string>&lt;b&gt;Store mail(s) to&lt;/b&gt;</string>
             </property>
             <property stdset="1">
                 <name>alignment</name>
                 <set>AlignCenter</set>
             </property>
             <property>
                 <name>hAlign</name>
             </property>
         </widget>
         <widget>
             <class>QLayoutWidget</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>Layout2</cstring>
             </property>
             <grid>
                 <property stdset="1">
                     <name>margin</name>
                     <number>0</number>
                 </property>
                 <property stdset="1">
                     <name>spacing</name>
                     <number>6</number>
                 </property>
                 <widget row="1"  column="1" >
                     <class>QComboBox</class>
                     <property stdset="1">
                         <name>name</name>
                         <cstring>folderSelection</cstring>
                     </property>
                     <property stdset="1">
                         <name>sizePolicy</name>
                         <sizepolicy>
                             <hsizetype>3</hsizetype>
                             <vsizetype>0</vsizetype>
                         </sizepolicy>
                     </property>
                 </widget>
                 <widget row="1"  column="0" >
                     <class>QLabel</class>
                     <property stdset="1">
                         <name>name</name>
                         <cstring>folderLabel</cstring>
                     </property>
                     <property stdset="1">
                         <name>text</name>
                         <string>Folder:</string>
                     </property>
                     <property stdset="1">
                         <name>alignment</name>
                         <set>AlignVCenter|AlignRight</set>
                     </property>
                     <property>
                         <name>hAlign</name>
                     </property>
                 </widget>
                 <widget row="0"  column="1" >
                     <class>QComboBox</class>
                     <property stdset="1">
                         <name>name</name>
                         <cstring>accountSelection</cstring>
                     </property>
                     <property stdset="1">
                         <name>sizePolicy</name>
                         <sizepolicy>
                             <hsizetype>3</hsizetype>
                             <vsizetype>0</vsizetype>
                         </sizepolicy>
                     </property>
                 </widget>
                 <widget row="0"  column="0" >
                     <class>QLabel</class>
                     <property stdset="1">
                         <name>name</name>
                         <cstring>accountlabel</cstring>
                     </property>
                     <property stdset="1">
                         <name>sizePolicy</name>
                         <sizepolicy>
                             <hsizetype>1</hsizetype>
                             <vsizetype>1</vsizetype>
                         </sizepolicy>
                     </property>
                     <property stdset="1">
                         <name>text</name>
                         <string>Account:</string>
                     </property>
                     <property stdset="1">
                         <name>alignment</name>
                         <set>AlignVCenter|AlignRight</set>
                     </property>
                     <property>
                         <name>hAlign</name>
                     </property>
                 </widget>
             </grid>
         </widget>
         <widget>
             <class>Line</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>Line1</cstring>
             </property>
             <property stdset="1">
                 <name>orientation</name>
                 <enum>Horizontal</enum>
             </property>
         </widget>
         <widget>
             <class>QCheckBox</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>newFoldersel</cstring>
             </property>
             <property stdset="1">
                 <name>text</name>
                 <string>Create new folder</string>
             </property>
         </widget>
         <widget>
             <class>QLineEdit</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>newFolderedit</cstring>
             </property>
             <property stdset="1">
                 <name>enabled</name>
                 <bool>false</bool>
             </property>
         </widget>
         <widget>
+            <class>QLabel</class>
+            <property stdset="1">
+                <name>name</name>
+                <cstring>newFolderLabel</cstring>
+            </property>
+            <property stdset="1">
+                <name>text</name>
+                <string>Prefix will prepend, no need to enter it!</string>
+            </property>
+            <property stdset="1">
+                <name>alignment</name>
+                <set>WordBreak|AlignCenter</set>
+            </property>
+            <property>
+                <name>hAlign</name>
+            </property>
+            <property>
+                <name>wordwrap</name>
+            </property>
+        </widget>
+        <widget>
             <class>Line</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>Line2</cstring>
             </property>
             <property stdset="1">
                 <name>orientation</name>
                 <enum>Horizontal</enum>
             </property>
         </widget>
         <widget>
             <class>QCheckBox</class>
             <property stdset="1">
                 <name>name</name>
                 <cstring>selMove</cstring>
             </property>
             <property stdset="1">
                 <name>text</name>
                 <string>Move mail(s)</string>
             </property>
         </widget>
         <spacer>
             <property>
                 <name>name</name>
                 <cstring>Spacer2</cstring>
             </property>
             <property stdset="1">
                 <name>orientation</name>
                 <enum>Vertical</enum>
             </property>
             <property stdset="1">
                 <name>sizeType</name>
                 <enum>Expanding</enum>
             </property>
             <property>
                 <name>sizeHint</name>
                 <size>
                     <width>20</width>
                     <height>20</height>
                 </size>
             </property>
         </spacer>
     </vbox>
 </widget>
 <connections>
     <connection>
         <sender>selMove</sender>
         <signal>clicked()</signal>
         <receiver>selectstoreui</receiver>
         <slot>slotMoveMail()</slot>
     </connection>
     <connection>
         <sender>newFoldersel</sender>
         <signal>clicked()</signal>
         <receiver>selectstoreui</receiver>
         <slot>slotCreateNewFolder()</slot>
     </connection>
-    <slot access="protected">slotMoveMail()</slot>
+    <connection>
+        <sender>accountSelection</sender>
+        <signal>activated(int)</signal>
+        <receiver>selectstoreui</receiver>
+        <slot>slotAccountselected(int)</slot>
+    </connection>
+    <connection>
+        <sender>folderSelection</sender>
+        <signal>activated(int)</signal>
+        <receiver>selectstoreui</receiver>
+        <slot>slotFolderSelected(int)</slot>
+    </connection>
+    <slot access="protected">slotFolderSelected(int)</slot>
+    <slot access="protected">slotAccountselected(int)</slot>
     <slot access="protected">slotCreateNewFolder()</slot>
+    <slot access="protected">slotMoveMail()</slot>
 </connections>
 <tabstops>
     <tabstop>accountSelection</tabstop>
     <tabstop>folderSelection</tabstop>
     <tabstop>newFoldersel</tabstop>
     <tabstop>newFolderedit</tabstop>
     <tabstop>selMove</tabstop>
 </tabstops>
 </UI>