someone forget to include opie2/odebug while switching from qDebug

to odebug ;)

23 files changed, 49 insertions, 7 deletions

diff --git a/noncore/net/mail/accountitem.cpp b/noncore/net/mail/accountitem.cpp
index ae28313..c1574fd 100644
--- a/noncore/net/mail/accountitem.cpp
+++ b/noncore/net/mail/accountitem.cpp
@@ -1,107 +1,108 @@
 
 #include "accountitem.h"
 #include "accountview.h"
 #include "newmaildir.h"
 #include "nntpgroupsdlg.h"
 #include "defines.h"
 
-/* OPIE */
 #include <libmailwrapper/mailtypes.h>
 #include <libmailwrapper/abstractmail.h>
 #include <libmailwrapper/mailwrapper.h>
+/* OPIE */
+#include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qpopupmenu.h>
 #include <qmessagebox.h>
 
 using namespace Opie::Core;
 #define SETPIX(x) if (!account->getOffline()) {setPixmap( 0,x);} else {setPixmap( 0, PIXMAP_OFFLINE );}
 /**
  * POP3 Account stuff
  */
 POP3viewItem::POP3viewItem( POP3account *a, AccountView *parent )
         : AccountViewItem( parent )
 {
     account = a;
     wrapper = AbstractMail::getWrapper( account );
     SETPIX(PIXMAP_POP3FOLDER);
 #if 0
     if (!account->getOffline())
     {
         setPixmap( 0,  );
     }
     else
     {
         setPixmap( 0, PIXMAP_OFFLINE );
     }
 #endif
     setText( 0, account->getAccountName() );
     setOpen( true );
 }
 
 POP3viewItem::~POP3viewItem()
 {
     delete wrapper;
 }
 
 AbstractMail *POP3viewItem::getWrapper()
 {
     return wrapper;
 }
 
 void POP3viewItem::refresh(QValueList<Opie::Core::OSmartPointer<RecMail> > & )
 {
     refresh();
 }
 
 void POP3viewItem::refresh()
 {
     if (account->getOffline()) return;
     QValueList<FolderP> *folders = wrapper->listFolders();
     QListViewItem *child = firstChild();
     while ( child )
     {
         QListViewItem *tmp = child;
         child = child->nextSibling();
         delete tmp;
     }
     QValueList<FolderP>::ConstIterator it;
     QListViewItem*item = 0;
     for ( it = folders->begin(); it!=folders->end(); ++it)
     {
         item = new POP3folderItem( (*it), this , item );
         item->setSelectable( (*it)->may_select());
     }
     delete folders;
 }
 
 RECBODYP POP3viewItem::fetchBody( const RecMailP &mail )
 {
     odebug << "POP3 fetchBody" << oendl; 
     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 )
     {
diff --git a/noncore/net/mail/accountview.cpp b/noncore/net/mail/accountview.cpp
index 0052061..662e555 100644
--- a/noncore/net/mail/accountview.cpp
+++ b/noncore/net/mail/accountview.cpp
@@ -1,106 +1,108 @@
 
 #include "accountview.h"
 #include "accountitem.h"
 #include "selectstore.h"
 
-/* OPIE */
 #include <libmailwrapper/settings.h>
 #include <libmailwrapper/mailwrapper.h>
 #include <libmailwrapper/mailtypes.h>
 #include <libmailwrapper/abstractmail.h>
+
+/* OPIE */
+#include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 
 using namespace Opie::Core;
 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();
     mhAccounts.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();
 
     imapAccounts.clear();
     mhAccounts.clear();
 
     mhAccounts.append(new MHviewItem(AbstractMail::defaultLocalfolder(),this));
 
     Account *it;
     for ( it = list.first(); it; it = list.next() )
     {
         if ( it->getType() == MAILLIB::A_IMAP )
         {
             IMAPaccount *imap = static_cast<IMAPaccount *>(it);
             odebug << "added IMAP " + imap->getAccountName() << oendl; 
             imapAccounts.append(new IMAPviewItem( imap, this ));
         }
         else if ( it->getType() == MAILLIB::A_POP3 )
         {
             POP3account *pop3 = static_cast<POP3account *>(it);
             odebug << "added POP3 " + pop3->getAccountName() << oendl; 
             /* must not be hold 'cause it isn't required */
             (void) new POP3viewItem( pop3, this );
         }
          else if ( it->getType() == MAILLIB::A_NNTP )
         {
             NNTPaccount *nntp = static_cast<NNTPaccount *>(it);
             odebug << "added NNTP " + nntp->getAccountName() << oendl; 
             /* must not be hold 'cause it isn't required */
             (void) new NNTPviewItem( nntp, this );
        }
      }
 }
 
 void AccountView::refresh(QListViewItem *item)
 {
 
     odebug << "AccountView refresh..." << oendl; 
     if ( item )
     {
         m_currentItem = item;
         QValueList<RecMailP> headerlist;
         AccountViewItem *view = static_cast<AccountViewItem *>(item);
         view->refresh(headerlist);
         emit refreshMailview(headerlist);
     }
 }
 
 void AccountView::refreshCurrent()
 {
     m_currentItem = currentItem();
     if ( !m_currentItem ) return;
diff --git a/noncore/net/mail/composemail.cpp b/noncore/net/mail/composemail.cpp
index fa703c4..b15e692 100644
--- a/noncore/net/mail/composemail.cpp
+++ b/noncore/net/mail/composemail.cpp
@@ -1,99 +1,100 @@
 #include <qt.h>
 
 #include <opie2/ofiledialog.h>
+#include <opie2/odebug.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/global.h>
 #include <qpe/contact.h>
 
 #include "composemail.h"
 
 #include <libmailwrapper/smtpwrapper.h>
 #include <libmailwrapper/storemail.h>
 #include <libmailwrapper/abstractmail.h>
 #include <libmailwrapper/mailtypes.h>
 
 using namespace Opie::Core;
 using namespace Opie::Ui;
 ComposeMail::ComposeMail( Settings *s, QWidget *parent, const char *name, bool modal, WFlags flags )
     : ComposeMailUI( parent, name, modal, flags )
 {
     settings = s;
     m_replyid = "";
 
     QString vfilename = Global::applicationFileName("addressbook",
                 "businesscard.vcf");
     Contact c;
     if (QFile::exists(vfilename)) {
         c = Contact::readVCard( vfilename )[0];
     }
 
     QStringList mails = c.emailList();
     QString defmail = c.defaultEmail();
 
     if (defmail.length()!=0) {
         fromBox->insertItem(defmail);
     }
     QStringList::ConstIterator sit = mails.begin();
     for (;sit!=mails.end();++sit) {
         if ( (*sit)==defmail)
             continue;
         fromBox->insertItem((*sit));
     }
     senderNameEdit->setText(c.firstName()+" "+c.lastName());
     Config cfg( "mail" );
     cfg.setGroup( "Compose" );
     checkBoxLater->setChecked( cfg.readBoolEntry( "sendLater", false ) );
 
     attList->addColumn( tr( "Name" ) );
     attList->addColumn( tr( "Size" ) );
 
     QList<Account> accounts = settings->getAccounts();
 
     Account *it;
     for ( it = accounts.first(); it; it = accounts.next() ) {
         if ( it->getType()==MAILLIB::A_SMTP ) {
            SMTPaccount *smtp = static_cast<SMTPaccount *>(it);
            smtpAccountBox->insertItem( smtp->getAccountName() );
            smtpAccounts.append( smtp );
         }
     }
 
     if ( smtpAccounts.count() > 0 ) {
         fillValues( smtpAccountBox->currentItem() );
     } else {
         QMessageBox::information( this, tr( "Problem" ),
                                   tr( "<p>Please create an SMTP account first.</p>" ),
                                   tr( "Ok" ) );
         return;
     }
 
     connect( smtpAccountBox, SIGNAL( activated(int) ), SLOT( fillValues(int) ) );
     connect( toButton, SIGNAL( clicked() ), SLOT( pickAddressTo() ) );
     connect( ccButton, SIGNAL( clicked() ), SLOT( pickAddressCC() ) );
     connect( bccButton, SIGNAL( clicked() ), SLOT( pickAddressBCC() ) );
     connect( replyButton, SIGNAL( clicked() ), SLOT( pickAddressReply() ) );
     connect( addButton, SIGNAL( clicked() ), SLOT( addAttachment() ) );
     connect( deleteButton, SIGNAL( clicked() ), SLOT( removeAttachment() ) );
 }
 
 void ComposeMail::pickAddress( QLineEdit *line )
 {
     QString names = AddressPicker::getNames();
     if ( line->text().isEmpty() ) {
         line->setText( names );
     } else if ( !names.isEmpty() ) {
         line->setText( line->text() + ", " + names );
     }
 }
 
 
 void ComposeMail::setTo( const QString & to )
 {
     toLine->setText( to );
 }
 
 void ComposeMail::setSubject( const QString & subject )
 {
  subjectLine->setText( subject );
 }
diff --git a/noncore/net/mail/editaccounts.cpp b/noncore/net/mail/editaccounts.cpp
index de064ca..b0ce57d 100644
--- a/noncore/net/mail/editaccounts.cpp
+++ b/noncore/net/mail/editaccounts.cpp
@@ -1,109 +1,112 @@
 
 #include "defines.h"
 #include "editaccounts.h"
 
 /* OPIE */
+#include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qt.h>
 #include <qstringlist.h>
 
 #include <libmailwrapper/nntpwrapper.h>
 
+using namespace Opie::Core;
+
 AccountListItem::AccountListItem( QListView *parent, Account *a)
         : QListViewItem( parent )
 {
     account = a;
     setText( 0, account->getAccountName() );
     QString ttext = "";
     switch (account->getType()) {
         case MAILLIB::A_NNTP:
             ttext="NNTP";
             break;
         case MAILLIB::A_POP3:
             ttext = "POP3";
             break;
         case MAILLIB::A_IMAP:
             ttext = "IMAP";
             break;
         case MAILLIB::A_SMTP:
             ttext = "SMTP";
             break;
         default:
             ttext = "UNKNOWN";
             break;
     }
     setText( 1, ttext);
 }
 
 EditAccounts::EditAccounts( Settings *s, QWidget *parent, const char *name, bool modal, WFlags flags )
         : EditAccountsUI( parent, name, modal, flags )
 {
     odebug << "New Account Configuration Widget" << oendl; 
     settings = s;
 
     mailList->addColumn( tr( "Account" ) );
     mailList->addColumn( tr( "Type" ) );
 
     newsList->addColumn( tr( "Account" ) );
 
     connect( newMail, SIGNAL( clicked() ), SLOT( slotNewMail() ) );
     connect( editMail, SIGNAL( clicked() ), SLOT( slotEditMail() ) );
     connect( deleteMail, SIGNAL( clicked() ), SLOT( slotDeleteMail() ) );
     connect( newNews, SIGNAL( clicked() ), SLOT( slotNewNews() ) );
     connect( editNews, SIGNAL( clicked() ), SLOT( slotEditNews() ) );
     connect( deleteNews, SIGNAL( clicked() ), SLOT( slotDeleteNews() ) );
 
     slotFillLists();
 }
 
 void EditAccounts::slotFillLists()
 {
     mailList->clear();
     newsList->clear();
 
     QList<Account> accounts = settings->getAccounts();
     Account *it;
     for ( it = accounts.first(); it; it = accounts.next() )
     {
         if ( it->getType()==MAILLIB::A_NNTP )
         {
             (void) new AccountListItem( newsList, it );
         }
         else
         {
             (void) new AccountListItem( mailList, it );
         }
     }
 }
 
 void EditAccounts::slotNewMail()
 {
     odebug << "New Mail Account" << oendl; 
     QString *selection = new QString();
     SelectMailType selType( selection, this, 0, true );
     selType.show();
     if ( QDialog::Accepted == selType.exec() )
     {
         slotNewAccount( *selection );
     }
 }
 
 void EditAccounts::slotNewAccount( const QString &type )
 {
     if ( type.compare( "IMAP" ) == 0 )
     {
         odebug << "-> config IMAP" << oendl; 
         IMAPaccount *account = new IMAPaccount();
         IMAPconfig imap( account, this, 0, true );
         if ( QDialog::Accepted == QPEApplication::execDialog( &imap ) )
         {
             settings->addAccount( account );
             account->save();
             slotFillLists();
         }
         else
         {
             account->remove();
         }
diff --git a/noncore/net/mail/libmailwrapper/abstractmail.cpp b/noncore/net/mail/libmailwrapper/abstractmail.cpp
index 1a26351..7c1c0e4 100644
--- a/noncore/net/mail/libmailwrapper/abstractmail.cpp
+++ b/noncore/net/mail/libmailwrapper/abstractmail.cpp
@@ -1,103 +1,105 @@
 #include "abstractmail.h"
 #include "imapwrapper.h"
 #include "pop3wrapper.h"
 #include "nntpwrapper.h"
 #include "mhwrapper.h"
 #include "mailtypes.h"
 
+#include <opie2/odebug.h>
+
 #include <qfile.h>
 #include <qtextstream.h>
 #include <stdlib.h>
 #include <libetpan/mailmime_content.h>
 #include <libetpan/mailmime.h>
 
 using namespace Opie::Core;
 AbstractMail* AbstractMail::getWrapper(IMAPaccount *a)
 {
     return new IMAPwrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(POP3account *a)
 {
     return new POP3wrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(NNTPaccount *a)
 {
     return new NNTPwrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(const QString&a,const QString&name)
 {
     return new MHwrapper(a,name);
 }
 
 AbstractMail* AbstractMail::getWrapper(Account*a)
 {
     if (!a) return 0;
     switch (a->getType()) {
         case MAILLIB::A_IMAP:
             return new IMAPwrapper((IMAPaccount*)a);
             break;
         case MAILLIB::A_POP3:
             return new POP3wrapper((POP3account*)a);
             break;
         case MAILLIB::A_NNTP:
             return new NNTPwrapper((NNTPaccount*)a);
             break;
         default:
             return 0;
     }
 }
 
 encodedString* AbstractMail::decode_String(const encodedString*text,const QString&enc)
 {
     odebug << "Decode string start" << oendl; 
     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);
     }
     odebug << "Decode string finished" << oendl; 
     return result;
 }
 
 QString AbstractMail::convert_String(const char*text)
 {
     //size_t index = 0;
     char*res = 0;
     int err = MAILIMF_NO_ERROR;
 
     QString result(text);
 
     /* due a bug in libetpan it isn't usable this moment */
 /*    int err = mailmime_encoded_phrase_parse("iso-8859-1",
         text, strlen(text),&index, "iso-8859-1",&res);*/
     //odebug << "Input: " << text << "" << oendl; 
     if (err == MAILIMF_NO_ERROR && res && strlen(res)) {
 //        result = QString(res);
 //        odebug << "Res: " << res << ", length: " << strlen(res) << "" << oendl; 
     }
     if (res) free(res);
     return result;
 }
 
 /* cp & paste from launcher */
diff --git a/noncore/net/mail/libmailwrapper/generatemail.cpp b/noncore/net/mail/libmailwrapper/generatemail.cpp
index 36ec232..eb322a7 100644
--- a/noncore/net/mail/libmailwrapper/generatemail.cpp
+++ b/noncore/net/mail/libmailwrapper/generatemail.cpp
@@ -1,101 +1,103 @@
 #include "generatemail.h"
 #include "mailwrapper.h"
 
 #include <libetpan/libetpan.h>
 
+#include <opie2/odebug.h>
+
 #include <qt.h>
 
 using namespace Opie::Core;
 const char* Generatemail::USER_AGENT="OpieMail v0.6";
 
 Generatemail::Generatemail()
 {
 }
 
 Generatemail::~Generatemail()
 {
 }
 
 void Generatemail::addRcpts( clist *list, mailimf_address_list *addr_list ) {
     clistiter *it, *it2;
 
     for ( it = clist_begin( addr_list->ad_list ); it; it = it->next ) {
         mailimf_address *addr;
         addr = (mailimf_address *) it->data;
 
         if ( addr->ad_type == MAILIMF_ADDRESS_MAILBOX ) {
             esmtp_address_list_add( list, addr->ad_data.ad_mailbox->mb_addr_spec, 0, NULL );
         } else if ( addr->ad_type == MAILIMF_ADDRESS_GROUP ) {
             clist *l = addr->ad_data.ad_group->grp_mb_list->mb_list;
             for ( it2 = clist_begin( l ); it2; it2 = it2->next ) {
                 mailimf_mailbox *mbox;
                 mbox = (mailimf_mailbox *) it2->data;
                 esmtp_address_list_add( list, mbox->mb_addr_spec, 0, NULL );
             }
         }
     }
 }
 
 char *Generatemail::getFrom( mailimf_field *ffrom) {
     char *from = NULL;
     if ( ffrom && (ffrom->fld_type == MAILIMF_FIELD_FROM)
             && ffrom->fld_data.fld_from->frm_mb_list && ffrom->fld_data.fld_from->frm_mb_list->mb_list ) {
         clist *cl = ffrom->fld_data.fld_from->frm_mb_list->mb_list;
         clistiter *it;
         for ( it = clist_begin( cl ); it; it = it->next ) {
             mailimf_mailbox *mb = (mailimf_mailbox *) it->data;
             from = strdup( mb->mb_addr_spec );
         }
     }
 
     return from;
 }
 
 char *Generatemail::getFrom( mailmime *mail ) {
     /* no need to delete - its just a pointer to structure content */
     mailimf_field *ffrom = 0;
     ffrom = getField( mail->mm_data.mm_message.mm_fields, MAILIMF_FIELD_FROM );
     return getFrom(ffrom);
 }
 
 mailimf_field *Generatemail::getField( mailimf_fields *fields, int type ) {
     mailimf_field *field;
     clistiter *it;
 
     it = clist_begin( fields->fld_list );
     while ( it ) {
         field = (mailimf_field *) it->data;
         if ( field->fld_type == type ) {
             return field;
         }
         it = it->next;
     }
 
     return NULL;
 }
 
 mailimf_address_list *Generatemail::parseAddresses(const QString&addr ) {
     mailimf_address_list *addresses;
 
     if ( addr.isEmpty() )
         return NULL;
 
     addresses = mailimf_address_list_new_empty();
 
     bool literal_open = false;
     unsigned int startpos = 0;
     QStringList list;
     QString s;
     unsigned int i = 0;
     for (; i < addr.length();++i) {
         switch (addr[i]) {
         case '\"':
             literal_open = !literal_open;
             break;
         case ',':
             if (!literal_open) {
                 s = addr.mid(startpos,i-startpos);
                 if (!s.isEmpty()) {
                     list.append(s);
                     odebug << "Appended " << s.latin1() << "" << oendl; 
                 }
diff --git a/noncore/net/mail/libmailwrapper/genericwrapper.cpp b/noncore/net/mail/libmailwrapper/genericwrapper.cpp
index fae4c99..3e4293b 100644
--- a/noncore/net/mail/libmailwrapper/genericwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/genericwrapper.cpp
@@ -1,100 +1,102 @@
 #include "genericwrapper.h"
 #include <libetpan/libetpan.h>
 #include "mailtypes.h"
 
+#include <opie2/odebug.h>
+
 using namespace Opie::Core;
 Genericwrapper::Genericwrapper()
     : AbstractMail()
 {
     bodyCache.clear();
     m_storage = 0;
     m_folder = 0;
 }
 
 Genericwrapper::~Genericwrapper()
 {
     if (m_folder) {
         mailfolder_free(m_folder);
     }
     if (m_storage) {
         mailstorage_free(m_storage);
     }
     cleanMimeCache();
 }
 
 void Genericwrapper::fillSingleBody(RecPartP&target,mailmessage*,mailmime*mime)
 {
     if (!mime) {
         return;
     }
     mailmime_field*field = 0;
     mailmime_single_fields fields;
     memset(&fields, 0, sizeof(struct mailmime_single_fields));
     if (mime->mm_mime_fields != NULL) {
         mailmime_single_fields_init(&fields, mime->mm_mime_fields,
             mime->mm_content_type);
     }
 
     mailmime_content*type = fields.fld_content;
     clistcell*current;
     if (!type) {
         target->setType("text");
         target->setSubtype("plain");
     } else {
         target->setSubtype(type->ct_subtype);
         switch(type->ct_type->tp_data.tp_discrete_type->dt_type) {
         case MAILMIME_DISCRETE_TYPE_TEXT:
             target->setType("text");
             break;
         case MAILMIME_DISCRETE_TYPE_IMAGE:
             target->setType("image");
             break;
         case MAILMIME_DISCRETE_TYPE_AUDIO:
             target->setType("audio");
             break;
         case MAILMIME_DISCRETE_TYPE_VIDEO:
             target->setType("video");
             break;
         case MAILMIME_DISCRETE_TYPE_APPLICATION:
             target->setType("application");
             break;
         case MAILMIME_DISCRETE_TYPE_EXTENSION:
         default:
             if (type->ct_type->tp_data.tp_discrete_type->dt_extension) {
                 target->setType(type->ct_type->tp_data.tp_discrete_type->dt_extension);
             }
             break;
         }
         if (type->ct_parameters) {
             fillParameters(target,type->ct_parameters);
         }
     }
     if (mime->mm_mime_fields && mime->mm_mime_fields->fld_list) {
         for (current=clist_begin(mime->mm_mime_fields->fld_list);current!=0;current=clist_next(current)) {
             field = (mailmime_field*)current->data;
             switch(field->fld_type) {
             case MAILMIME_FIELD_TRANSFER_ENCODING:
                 target->setEncoding(getencoding(field->fld_data.fld_encoding));
                 break;
             case MAILMIME_FIELD_ID:
                 target->setIdentifier(field->fld_data.fld_id);
                 break;
             case MAILMIME_FIELD_DESCRIPTION:
                 target->setDescription(field->fld_data.fld_description);
                 break;
             default:
                 break;
             }
         }
     }
 }
 
 void Genericwrapper::fillParameters(RecPartP&target,clist*parameters)
 {
     if (!parameters) {return;}
     clistcell*current=0;
     mailmime_parameter*param;
     for (current=clist_begin(parameters);current!=0;current=clist_next(current)) {
         param = (mailmime_parameter*)current->data;
         if (param) {
             target->addParameter(QString(param->pa_name).lower(),QString(param->pa_value));
diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.cpp b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
index 35468fe..9b7c0e0 100644
--- a/noncore/net/mail/libmailwrapper/imapwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
@@ -1,100 +1,101 @@
 #include <stdlib.h>
 #include <libetpan/libetpan.h>
 #include <qpe/global.h>
 #include <opie2/oapplication.h>
+#include <opie2/odebug.h>
 
 #include "imapwrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 
 using namespace Opie::Core;
 IMAPwrapper::IMAPwrapper( IMAPaccount *a )
     : AbstractMail()
 {
     account = a;
     m_imap = 0;
     m_Lastmbox = "";
 }
 
 IMAPwrapper::~IMAPwrapper()
 {
     logout();
 }
 
 /* to avoid to often select statements in loops etc.
    we trust that we are logged in and connection is established!*/
 int IMAPwrapper::selectMbox(const QString&mbox)
 {
     if (mbox == m_Lastmbox) {
         return MAILIMAP_NO_ERROR;
     }
     int err = mailimap_select( m_imap, (char*)mbox.latin1());
     if ( err != MAILIMAP_NO_ERROR ) {
         odebug << "error selecting mailbox: " << m_imap->imap_response << "" << oendl; 
         m_Lastmbox = "";
         return err;
     }
     m_Lastmbox = mbox;
     return err;
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     qApp->processEvents();
     odebug << "IMAP: " << current << " of " << maximum << "" << oendl; 
 }
 
 bool IMAPwrapper::start_tls(bool force_tls)
 {
     int err;
     bool try_tls;
     mailimap_capability_data * cap_data = 0;
 
     err = mailimap_capability(m_imap,&cap_data);
     if (err != MAILIMAP_NO_ERROR) {
         Global::statusMessage("error getting capabilities!");
         odebug << "error getting capabilities!" << oendl; 
         return false;
     }
     clistiter * cur;
     for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) {
         struct mailimap_capability * cap;
         cap  = (struct mailimap_capability *)clist_content(cur);
         if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) {
             if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) {
                 try_tls = true;
                 break;
             }
         }
     }
     if (cap_data) {
         mailimap_capability_data_free(cap_data);
     }
     if (try_tls) {
         err =  mailimap_starttls(m_imap);
         if (err != MAILIMAP_NO_ERROR && force_tls) {
             Global::statusMessage(tr("Server has no TLS support!"));
             odebug << "Server has no TLS support!" << oendl; 
             try_tls = false;
         } else {
             mailstream_low * low;
             mailstream_low * new_low;
             low = mailstream_get_low(m_imap->imap_stream);
             if (!low) {
                 try_tls = false;
             } else {
                 int fd = mailstream_low_get_fd(low);
                 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
                     mailstream_low_free(low);
                     mailstream_set_low(m_imap->imap_stream, new_low);
                 } else {
                     try_tls = false;
                 }
             }
         }
    }
    return try_tls;
 }
 
 void IMAPwrapper::login()
 {
diff --git a/noncore/net/mail/libmailwrapper/logindialog.cpp b/noncore/net/mail/libmailwrapper/logindialog.cpp
index c9ae190..ce705b2 100644
--- a/noncore/net/mail/libmailwrapper/logindialog.cpp
+++ b/noncore/net/mail/libmailwrapper/logindialog.cpp
@@ -1,29 +1,33 @@
 #include <qlineedit.h>
 
 #include "logindialog.h"
 
+#include <opie2/odebug.h>
+
+using namespace Opie::Core;
+
 LoginDialog::LoginDialog(const QString&user,const QString&pass, QWidget *parent, const char *name, bool modal, WFlags flags )
     : LoginDialogUI( parent, name, modal, flags )
 {
     userLine->setText( (user.isEmpty()?QString(""):user) );
     passLine->setText( (pass.isEmpty()?QString(""):pass) );
     _user = user;
     _pass = pass;
 
     if ( user.isEmpty() ) {
         userLine->setFocus();
     } else {
         passLine->setFocus();
     }
 }
 
 void LoginDialog::accept()
 {
     //_user.replace( 0, _user.length(), userLine->text() );
     //_pass.replace( 0, _pass.length(), passLine->text() );
     _user = userLine->text();
     _pass = passLine->text();
 
     odebug << "User im accept: |" << _user.latin1() << "|" << oendl; 
     QDialog::accept();
 }
diff --git a/noncore/net/mail/libmailwrapper/mailtypes.cpp b/noncore/net/mail/libmailwrapper/mailtypes.cpp
index 6d44db4..d4395a2 100644
--- a/noncore/net/mail/libmailwrapper/mailtypes.cpp
+++ b/noncore/net/mail/libmailwrapper/mailtypes.cpp
@@ -1,97 +1,100 @@
 #include "mailtypes.h"
+
+#include <opie2/odebug.h>
+
 #include <stdlib.h>
 
 using namespace Opie::Core;
 RecMail::RecMail()
     :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_size(0),msg_flags(7)
 {
     init();
 }
 
 RecMail::RecMail(const RecMail&old)
     :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_flags(7)
 {
     init();
     copy_old(old);
     odebug << "Copy constructor RecMail" << oendl; 
 }
 
 RecMail::~RecMail()
 {
     wrapper = 0;
 }
 
 void RecMail::copy_old(const RecMail&old)
 {
     subject = old.subject;
     date = old.date;
     mbox = old.mbox;
     msg_id = old.msg_id;
     msg_size = old.msg_size;
     msg_number = old.msg_number;
     from = old.from;
     msg_flags = old.msg_flags;
     to = old.to;
     cc = old.cc;
     bcc = old.bcc;
     wrapper = old.wrapper;
     in_reply_to = old.in_reply_to;
     references = old.references;
     replyto = old.replyto;
 }
 
 void RecMail::init()
 {
     to.clear();
     cc.clear();
     bcc.clear();
     in_reply_to.clear();
     references.clear();
     wrapper = 0;
 }
 
 void RecMail::setWrapper(AbstractMail*awrapper)
 {
     wrapper = awrapper;
 }
 
 AbstractMail* RecMail::Wrapper()
 {
     return wrapper;
 }
 
 void RecMail::setTo(const QStringList&list)
 {
     to = list;
 }
 
 const QStringList&RecMail::To()const
 {
     return to;
 }
 
 void RecMail::setCC(const QStringList&list)
 {
     cc = list;
 }
 
 const QStringList&RecMail::CC()const
 {
     return cc;
 }
 
 void RecMail::setBcc(const QStringList&list)
 {
     bcc = list;
 }
 
 const QStringList& RecMail::Bcc()const
 {
     return bcc;
 }
 
 void RecMail::setInreply(const QStringList&list)
 {
     in_reply_to = list;
 }
 
diff --git a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
index df2112f..a030cca 100644
--- a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
@@ -1,102 +1,104 @@
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <stdlib.h>
+
+#include <opie2/odebug.h>
 #include <qpe/global.h>
 
 using namespace Opie::Core;
 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, QValueList<RecMailP> &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) {
         odebug << "Error initializing mbox" << oendl; 
         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()));
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* MBOXwrapper::listFolders()
 {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     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) {
         FolderP inb=new Folder(*it,"/");
         folders->append(inb);
     }
     return folders;
 }
 
 void MBOXwrapper::deleteMail(const RecMailP & 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) {
         odebug << "Error initializing mbox" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
     r = mailsession_remove_message(folder->fld_session,mail->getNumber());
     if (r != MAIL_NO_ERROR) {
         odebug << "error deleting mail" << oendl; 
     }
     mailfolder_free(folder);
     mailstorage_free(storage);
 }
 
 void MBOXwrapper::answeredMail(const RecMailP&)
 {
 }
 
 RecBodyP MBOXwrapper::fetchBody( const RecMailP &mail )
 {
     RecBodyP body = new RecBody();
     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);
diff --git a/noncore/net/mail/libmailwrapper/mhwrapper.cpp b/noncore/net/mail/libmailwrapper/mhwrapper.cpp
index cd7cecb..403afcf 100644
--- a/noncore/net/mail/libmailwrapper/mhwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mhwrapper.cpp
@@ -1,105 +1,106 @@
 #include "mhwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <stdlib.h>
 #include <qpe/global.h>
 #include <opie2/oprocess.h>
+#include <opie2/odebug.h>
 
 using namespace Opie::Core;
 MHwrapper::MHwrapper(const QString & mbox_dir,const QString&mbox_name)
     : Genericwrapper(),MHPath(mbox_dir),MHName(mbox_name)
 {
     if (MHPath.length()>0) {
         if (MHPath[MHPath.length()-1]=='/') {
             MHPath=MHPath.left(MHPath.length()-1);
         }
         odebug << MHPath << oendl; 
         QDir dir(MHPath);
         if (!dir.exists()) {
             dir.mkdir(MHPath);
         }
         init_storage();
     }
 }
 
 void MHwrapper::init_storage()
 {
     int r;
     QString pre = MHPath;
     if (!m_storage) {
         m_storage = mailstorage_new(NULL);
         r = mh_mailstorage_init(m_storage,(char*)pre.latin1(),0,0,0);
         if (r != MAIL_NO_ERROR) {
             odebug << "error initializing storage" << oendl; 
             mailstorage_free(m_storage);
             m_storage = 0;
             return;
         }
     }
     r = mailstorage_connect(m_storage);
     if (r!=MAIL_NO_ERROR) {
         odebug << "error connecting storage" << oendl; 
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 void MHwrapper::clean_storage()
 {
     if (m_storage) {
         mailstorage_disconnect(m_storage);
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 MHwrapper::~MHwrapper()
 {
     clean_storage();
 }
 
 void MHwrapper::listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target )
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     QString f = buildPath(mailbox);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         odebug << "listMessages: error selecting folder!" << oendl; 
         return;
     }
     parseList(target,m_storage->sto_session,f);
     Global::statusMessage(tr("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* MHwrapper::listFolders()
 {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     /* this is needed! */
     if (m_storage) mailstorage_disconnect(m_storage);
     init_storage();
     if (!m_storage) {
         return folders;
     }
     mail_list*flist = 0;
     clistcell*current=0;
     int r = mailsession_list_folders(m_storage->sto_session,NULL,&flist);
     if (r != MAIL_NO_ERROR || !flist) {
         odebug << "error getting folder list" << oendl; 
         return folders;
     }
     for (current=clist_begin(flist->mb_list);current!=0;current=clist_next(current)) {
         QString t = (char*)current->data;
         t.replace(0,MHPath.length(),"");
         folders->append(new MHFolder(t,MHPath));
     }
     mail_list_free(flist);
     return folders;
 }
 
 void MHwrapper::deleteMail(const RecMailP&mail)
diff --git a/noncore/net/mail/libmailwrapper/nntpwrapper.cpp b/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
index 5d5011a..c99b97c 100644
--- a/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
@@ -1,106 +1,107 @@
 #include "nntpwrapper.h"
 #include "logindialog.h"
 #include "mailtypes.h"
 
 #include <qfile.h>
 
 #include <stdlib.h>
 
 #include <libetpan/libetpan.h>
 
+#include <opie2/odebug.h>
 
 #define HARD_MSG_SIZE_LIMIT 5242880
 
 using namespace Opie::Core;
 NNTPwrapper::NNTPwrapper( NNTPaccount *a )
 : Genericwrapper() {
     account = a;
     m_nntp = NULL;
     msgTempName = a->getFileName()+"_msg_cache";
     last_msg_id = 0;
 }
 
 NNTPwrapper::~NNTPwrapper() {
     logout();
     QFile msg_cache(msgTempName);
     if (msg_cache.exists()) {
         msg_cache.remove();
     }
 }
 
 void NNTPwrapper::nntp_progress( size_t current, size_t maximum ) {
     odebug << "NNTP: " << current << " of " << maximum << "" << oendl; 
 }
 
 
 RecBodyP NNTPwrapper::fetchBody( const RecMailP &mail ) {
     int err = NEWSNNTP_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     RecBodyP body = new RecBody();
     login();
     if ( !m_nntp ) {
         return body;
     }
 
     mailmessage * mailmsg;
     if (mail->Msgsize()>HARD_MSG_SIZE_LIMIT) {
         odebug << "Message to large: " << mail->Msgsize() << "" << oendl; 
         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_nntp->sto_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 NNTPwrapper::listMessages(const QString & which, QValueList<Opie::Core::OSmartPointer<RecMail> > &target )
 {
     login();
     if (!m_nntp)
         return;
     uint32_t res_messages,res_recent,res_unseen;
     mailsession_status_folder(m_nntp->sto_session,(char*)which.latin1(),&res_messages,&res_recent,&res_unseen);
diff --git a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
index c586c29..3cfd1ee 100644
--- a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
@@ -1,104 +1,105 @@
 #include <stdlib.h>
 #include "pop3wrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 #include <libetpan/libetpan.h>
+
+#include <opie2/odebug.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
 
 using namespace Opie::Core;
 POP3wrapper::POP3wrapper( POP3account *a )
 : Genericwrapper() {
     account = a;
     m_pop3 = 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 ) {
     odebug << "POP3: " << current << " of " << maximum << "" << oendl; 
 }
 
 RecBodyP POP3wrapper::fetchBody( const RecMailP &mail ) {
     int err = MAILPOP3_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     RecBodyP body = new RecBody();
 
     login();
     if ( !m_pop3 ) {
         return body;
     }
 
     mailmessage * mailmsg;
     if (mail->Msgsize()>HARD_MSG_SIZE_LIMIT) {
         odebug << "Message to large: " << mail->Msgsize() << "" << oendl; 
         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_pop3->sto_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 &, QValueList<Opie::Core::OSmartPointer<RecMail> > &target )
 {
     login();
     if (!m_pop3)
         return;
     uint32_t res_messages,res_recent,res_unseen;
     mailsession_status_folder(m_pop3->sto_session,"INBOX",&res_messages,&res_recent,&res_unseen);
diff --git a/noncore/net/mail/libmailwrapper/settings.cpp b/noncore/net/mail/libmailwrapper/settings.cpp
index de36eeb..3c9b25c 100644
--- a/noncore/net/mail/libmailwrapper/settings.cpp
+++ b/noncore/net/mail/libmailwrapper/settings.cpp
@@ -1,99 +1,100 @@
 #include <stdlib.h>
 #include <qdir.h>
 
+#include <opie2/odebug.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" );
         odebug << "$HOME/Applications/opiemail created" << oendl; 
     }
 }
 
 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++ ) {
         odebug << "Added IMAP account" << oendl; 
         IMAPaccount *account = new IMAPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList pop3 = dir.entryList( "pop3-*" );
     for ( it = pop3.begin(); it != pop3.end(); it++ ) {
         odebug << "Added POP account" << oendl; 
         POP3account *account = new POP3account( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList smtp = dir.entryList( "smtp-*" );
     for ( it = smtp.begin(); it != smtp.end(); it++ ) {
         odebug << "Added SMTP account" << oendl; 
         SMTPaccount *account = new SMTPaccount( (*it).replace(0, 5, "") );
         accounts.append( account );
     }
 
     QStringList nntp = dir.entryList( "nntp-*" );
     for ( it = nntp.begin(); it != nntp.end(); it++ ) {
         odebug << "Added NNTP account" << oendl; 
         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;
diff --git a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
index ba78c3b..db7a8ee 100644
--- a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
@@ -1,103 +1,104 @@
 #include "smtpwrapper.h"
 #include "mailwrapper.h"
 #include "abstractmail.h"
 #include "logindialog.h"
 #include "mailtypes.h"
 #include "sendmailprogress.h"
 
+#include <opie2/odebug.h>
 #include <qt.h>
 
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include <libetpan/libetpan.h>
 
 
 using namespace Opie::Core;
 progressMailSend*SMTPwrapper::sendProgress = 0;
 
 SMTPwrapper::SMTPwrapper(SMTPaccount * aSmtp )
     : Generatemail()
 {
     m_SmtpAccount = aSmtp;
     Config cfg( "mail" );
     cfg.setGroup( "Status" );
     m_queuedMail =  cfg.readNumEntry( "outgoing", 0 );
     emit queuedMails( m_queuedMail );
     connect( this, SIGNAL( queuedMails(int) ), this, SLOT( emitQCop(int) )  );
     m_smtp = 0;
 }
 
 SMTPwrapper::~SMTPwrapper()
 {
     disc_server();
 }
 
 void SMTPwrapper::emitQCop( int queued ) {
     QCopEnvelope env( "QPE/Pim", "outgoingMails(int)" );
     env << queued;
 }
 
 QString SMTPwrapper::mailsmtpError( int errnum ) {
     switch ( errnum ) {
     case MAILSMTP_NO_ERROR:
         return tr( "No error" );
     case MAILSMTP_ERROR_UNEXPECTED_CODE:
         return tr( "Unexpected error code" );
     case MAILSMTP_ERROR_SERVICE_NOT_AVAILABLE:
         return tr( "Service not available" );
     case MAILSMTP_ERROR_STREAM:
         return tr( "Stream error" );
     case MAILSMTP_ERROR_HOSTNAME:
         return tr( "gethostname() failed" );
     case MAILSMTP_ERROR_NOT_IMPLEMENTED:
         return tr( "Not implemented" );
     case MAILSMTP_ERROR_ACTION_NOT_TAKEN:
         return tr( "Error, action not taken" );
     case MAILSMTP_ERROR_EXCEED_STORAGE_ALLOCATION:
         return tr( "Data exceeds storage allocation" );
     case MAILSMTP_ERROR_IN_PROCESSING:
         return tr( "Error in processing" );
     case MAILSMTP_ERROR_STARTTLS_NOT_SUPPORTED:
         return tr( "Starttls not supported" );
         //      case MAILSMTP_ERROR_INSUFFISANT_SYSTEM_STORAGE:
         //        return tr( "Insufficient system storage" );
     case MAILSMTP_ERROR_MAILBOX_UNAVAILABLE:
         return tr( "Mailbox unavailable" );
     case MAILSMTP_ERROR_MAILBOX_NAME_NOT_ALLOWED:
         return tr( "Mailbox name not allowed" );
     case MAILSMTP_ERROR_BAD_SEQUENCE_OF_COMMAND:
         return tr( "Bad command sequence" );
     case MAILSMTP_ERROR_USER_NOT_LOCAL:
         return tr( "User not local" );
     case MAILSMTP_ERROR_TRANSACTION_FAILED:
         return tr( "Transaction failed" );
     case MAILSMTP_ERROR_MEMORY:
         return tr( "Memory error" );
     case MAILSMTP_ERROR_CONNECTION_REFUSED:
         return tr( "Connection refused" );
     default:
         return tr( "Unknown error code" );
     }
 }
 
 
 void SMTPwrapper::progress( size_t current, size_t maximum ) {
     if (SMTPwrapper::sendProgress) {
         SMTPwrapper::sendProgress->setSingleMail(current, maximum );
         qApp->processEvents();
     }
 }
 
 void SMTPwrapper::storeMail(const char*mail, size_t length, const QString&box) {
     if (!mail)
         return;
     QString localfolders = AbstractMail::defaultLocalfolder();
     AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     wrap->createMbox(box);
     wrap->storeMessage(mail,length,box);
     delete wrap;
 }
 
 void SMTPwrapper::smtpSend( mailmime *mail,bool later) {
     clist *rcpts = 0;
diff --git a/noncore/net/mail/libmailwrapper/statusmail.cpp b/noncore/net/mail/libmailwrapper/statusmail.cpp
index 51383f6..7e14df3 100644
--- a/noncore/net/mail/libmailwrapper/statusmail.cpp
+++ b/noncore/net/mail/libmailwrapper/statusmail.cpp
@@ -1,90 +1,94 @@
 #include "statusmail.h"
 
+#include <opie2/odebug.h>
+
+using namespace Opie::Core;
+
 StatusMail::StatusMail(QList<Account>&list)
 {
     currentImapStat.message_count=0;
     currentImapStat.message_unseen=0;
     currentImapStat.message_recent=0;
     lastPop3Stat = currentImapStat;
     currentPop3Stat = currentImapStat;
     connectionList.setAutoDelete(true);
     connectionList.clear();
     initAccounts(list);
 }
 
 StatusMail::~StatusMail()
 {
 }
 
 void StatusMail::initAccounts(QList<Account>&accounts)
 {
 
     Account *it;
     folderStat currentStat;
     AbstractMail * current = 0;
     currentPop3Stat.message_count=0;
     currentPop3Stat.message_recent=0;
     currentPop3Stat.message_unseen=0;
     for ( it = accounts.first(); it; it = accounts.next() ) {
         if ( it->getType()==MAILLIB::A_IMAP && !it->getOffline() ) {
             IMAPaccount*ima = static_cast<IMAPaccount *>(it);
             current = AbstractMail::getWrapper(ima);
             connectionList.append(current);
             current->statusFolder(currentStat);
             currentImapStat.message_count+=currentStat.message_unseen;
             currentImapStat.message_count+=currentStat.message_recent;
             currentImapStat.message_count+=currentStat.message_count;
         } else if ( it->getType() == MAILLIB::A_POP3 && !it->getOffline() ) {
             POP3account *pop3 = static_cast<POP3account *>(it);
             current = AbstractMail::getWrapper(pop3);
             connectionList.append(current);
             current->statusFolder(currentStat);
             currentPop3Stat.message_count+=currentStat.message_count;
         }
         current->logout();
     }
     odebug << "Pop3 init count: " << currentPop3Stat.message_count << "" << oendl; 
     currentPop3Stat.message_recent = currentPop3Stat.message_unseen = 0;
     lastPop3Stat.message_unseen = currentPop3Stat.message_unseen;
     lastPop3Stat.message_recent = currentPop3Stat.message_recent;
     lastPop3Stat.message_count = currentPop3Stat.message_count;
 }
 
 void StatusMail::reset_status()
 {
     lastPop3Stat = currentPop3Stat;
 }
 
 void StatusMail::check_current_stat(folderStat&targetStat)
 {
     AbstractMail*it = 0;
     folderStat currentStat;
     currentPop3Stat.message_recent = 0;
     currentPop3Stat.message_count = 0;
     currentPop3Stat.message_unseen = 0;
     currentImapStat = currentPop3Stat;
     for ( it = connectionList.first(); it; it = connectionList.next() ) {
         it->statusFolder(currentStat);
         it->logout();
         if (it->getType() == MAILLIB::A_IMAP) {
             currentImapStat.message_unseen+=currentStat.message_unseen;
             currentImapStat.message_recent+=currentStat.message_recent;
             currentImapStat.message_count+=currentStat.message_count;
         } else if (it->getType() == MAILLIB::A_POP3) {
             currentPop3Stat.message_count+=currentStat.message_count;
             odebug << "Pop3 count: " << currentPop3Stat.message_count << "" << oendl; 
         }
     }
     odebug << "Pop3 last: " << lastPop3Stat.message_count << "" << oendl; 
     if (currentPop3Stat.message_count > lastPop3Stat.message_count) {
         currentPop3Stat.message_recent = currentPop3Stat.message_count - lastPop3Stat.message_count;
         currentPop3Stat.message_unseen = currentPop3Stat.message_recent;
     } else {
         lastPop3Stat.message_count = currentPop3Stat.message_count;
         currentPop3Stat.message_recent = currentPop3Stat.message_unseen = 0;
     }
     targetStat = currentImapStat;
     targetStat.message_unseen+=currentPop3Stat.message_unseen;
     targetStat.message_recent+=currentPop3Stat.message_recent;
     targetStat.message_count+=currentPop3Stat.message_count;
 }
diff --git a/noncore/net/mail/libmailwrapper/storemail.cpp b/noncore/net/mail/libmailwrapper/storemail.cpp
index 546d756..4add8a1 100644
--- a/noncore/net/mail/libmailwrapper/storemail.cpp
+++ b/noncore/net/mail/libmailwrapper/storemail.cpp
@@ -1,91 +1,91 @@
 #include "storemail.h"
 #include "mailwrapper.h"
 #include "settings.h"
 #include "abstractmail.h"
 
 #include <libetpan/libetpan.h>
-
+#include <opie2/odebug.h>
 #include <qstring.h>
 
 #include <stdlib.h>
 
 using namespace Opie::Core;
 Storemail::Storemail(Account*aAccount,const QString&aFolder)
     : Generatemail()
 {
     wrapper = 0;
     m_Account = aAccount;
     m_tfolder = aFolder;
     wrapper = AbstractMail::getWrapper(m_Account);
     if (wrapper) {
         wrapper->createMbox(m_tfolder);
     }
 }
 
 Storemail::Storemail(const QString&dir,const QString&aFolder)
     : Generatemail()
 {
     wrapper = 0;
     m_Account = 0;
     m_tfolder = aFolder;
     wrapper = AbstractMail::getWrapper(dir);
     if (wrapper) {
         wrapper->createMbox(m_tfolder);
     }
 }
 
 Storemail::Storemail(const QString&aFolder)
     : Generatemail()
 {
     wrapper = 0;
     m_Account = 0;
     m_tfolder = aFolder;
     wrapper = AbstractMail::getWrapper(AbstractMail::defaultLocalfolder());
     if (wrapper) {
         wrapper->createMbox(m_tfolder);
     }
 }
 
 Storemail::~Storemail()
 {
 }
 
 int Storemail::storeMail(const Opie::Core::OSmartPointer<Mail>&mail)
 {
     if (!wrapper) return 0;
     int ret = 1;
 
     mailmime * mimeMail = 0;
     mimeMail = createMimeMail(mail );
     if ( mimeMail == NULL ) {
         odebug << "storeMail: error creating mime mail" << oendl; 
         return 0;
     }
     char *data;
     size_t size;
     data = 0;
 
     mailmessage * msg = 0;
     msg = mime_message_init(mimeMail);
     mime_message_set_tmpdir(msg,getenv( "HOME" ));
     int r = mailmessage_fetch(msg,&data,&size);
     mime_message_detach_mime(msg);
     mailmessage_free(msg);
     msg = 0;
     if (r != MAIL_NO_ERROR || !data) {
         odebug << "Error fetching mime..." << oendl; 
         ret = 0;
     }
 
     if (ret) {
         wrapper->storeMessage(data,size,m_tfolder);
     }
 
     if (data) {
         free(data);
     }
     if (mimeMail) {
         mailmime_free( mimeMail );
     }
     return ret;
 }
diff --git a/noncore/net/mail/mainwindow.cpp b/noncore/net/mail/mainwindow.cpp
index 4c87d64..979b73a 100644
--- a/noncore/net/mail/mainwindow.cpp
+++ b/noncore/net/mail/mainwindow.cpp
@@ -1,107 +1,109 @@
 #include <qlabel.h>
 #include <qvbox.h>
 #include <qheader.h>
 #include <qtimer.h>
 #include <qlayout.h>
 
+#include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 
 #include "defines.h"
 #include "mainwindow.h"
 
+using namespace Opie::Core;
 
 MainWindow::MainWindow( QWidget *parent, const char *name, WFlags flags )
     : QMainWindow( parent, name, flags )
 {
 
     setCaption( tr( "Mail" ) );
     setToolBarsMovable( false );
 
     toolBar = new QToolBar( this );
     menuBar = new QMenuBar( toolBar );
     mailMenu = new QPopupMenu( menuBar );
     menuBar->insertItem( tr( "Mail" ), mailMenu );
     settingsMenu = new QPopupMenu( menuBar );
     menuBar->insertItem( tr( "Settings" ), settingsMenu );
 
     addToolBar( toolBar );
     toolBar->setHorizontalStretchable( true );
 
     QLabel *spacer = new QLabel( toolBar );
     spacer->setBackgroundMode( QWidget::PaletteButton );
     toolBar->setStretchableWidget( spacer );
 
     composeMail = new QAction( tr( "Compose new mail" ), ICON_COMPOSEMAIL,
                                0, 0, this );
     composeMail->addTo( toolBar );
     composeMail->addTo( mailMenu );
 
     sendQueued = new QAction( tr( "Send queued mails" ), ICON_SENDQUEUED,
                               0, 0, this );
     sendQueued->addTo( toolBar );
     sendQueued->addTo( mailMenu );
 
     /*
     syncFolders = new QAction( tr( "Sync mailfolders" ), ICON_SYNC,
                                0, 0, this );
     syncFolders->addTo( toolBar );
     syncFolders->addTo( mailMenu );
     */
 
     showFolders = new QAction( tr( "Show/Hide folders" ), ICON_SHOWFOLDERS,
                                0, 0, this, 0, true );
     showFolders->addTo( toolBar );
     showFolders->addTo( mailMenu );
     showFolders->setOn( true );
     connect(showFolders, SIGNAL( toggled(bool) ),
             SLOT( slotShowFolders(bool) ) );
 
     /*
       searchMails = new QAction( tr( "Search mails" ), QIconSet( Resource::loadPixmap("find") ),
                                0, 0, this );
     searchMails->addTo( toolBar );
     searchMails->addTo( mailMenu );
     */
 
     deleteMails = new QAction(tr("Delete Mail"), QIconSet( Resource::loadPixmap("trash")), 0, 0, this);
     deleteMails->addTo( toolBar );
     deleteMails->addTo( mailMenu );
     connect( deleteMails, SIGNAL( activated() ),
              SLOT( slotDeleteMail() ) );
 
     editSettings = new QAction( tr( "Edit settings" ), QIconSet( Resource::loadPixmap("SettingsIcon") ) ,
                                 0, 0, this );
     editSettings->addTo( settingsMenu );
     connect( editSettings, SIGNAL( activated() ),
              SLOT( slotEditSettings() ) );
     editAccounts = new QAction( tr( "Configure accounts" ), QIconSet( Resource::loadPixmap("mail/editaccounts") ) ,
                                 0, 0, this );
     editAccounts->addTo( settingsMenu );
 
     //setCentralWidget( view );
 
     QVBox* wrapperBox = new QVBox( this );
     setCentralWidget( wrapperBox );
 
     QWidget *view = new QWidget( wrapperBox );
 
     layout = new QBoxLayout ( view, QBoxLayout::LeftToRight );
 
     folderView = new AccountView( view );
     folderView->header()->hide();
     folderView->setRootIsDecorated( true );
     folderView->addColumn( tr( "Mailbox" ) );
 
     layout->addWidget( folderView );
 
     mailView = new QListView( view );
     mailView->addColumn( tr( "" ) );
     mailView->addColumn( tr( "Subject" ),QListView::Manual );
     mailView->addColumn( tr( "Sender" ),QListView::Manual );
     mailView->addColumn( tr( "Size" ),QListView::Manual);
     mailView->addColumn( tr( "Date" ));
     mailView->setAllColumnsShowFocus(true);
     mailView->setSorting(-1);
 
     statusWidget = new StatusWidget( wrapperBox );
     statusWidget->hide();
diff --git a/noncore/net/mail/nntpgroups.cpp b/noncore/net/mail/nntpgroups.cpp
index 3243ee3..d81d8b1 100644
--- a/noncore/net/mail/nntpgroups.cpp
+++ b/noncore/net/mail/nntpgroups.cpp
@@ -1,62 +1,64 @@
 #include "nntpgroups.h"
 
 #include <libmailwrapper/settings.h>
-
+#include <opie2/odebug.h>
 #include <qlistview.h>
 #include <qlineedit.h>
 
+using namespace Opie::Core;
+
 NNTPGroups::NNTPGroups(NNTPaccount *account, QWidget* parent, const char* name, WFlags fl)
     : NNTPGroupsUI(parent,name,fl),subscribedGroups()
 {
     m_Account = account;
     fillGroups();
 }
 
 NNTPGroups::~NNTPGroups()
 {
     
 }
 
 void NNTPGroups::slotGetNG()
 {
     if (!m_Account) return;
     GroupListView->clear();
     NNTPwrapper tmp( m_Account );
     QString filter = Groupfilteredit->text();
     QStringList list =  tmp.listAllNewsgroups(filter);
     subscribedGroupsNotListed = subscribedGroups;
     for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
          QCheckListItem *item;
          item = new QCheckListItem( GroupListView, (*it), QCheckListItem::CheckBox );
          if ( subscribedGroups.contains( (*it) ) >= 1 ) {
              item->setOn( true );
              subscribedGroupsNotListed.remove((*it));
          }
     }
 }
 
 void NNTPGroups::fillGroups()
 {
     if (!m_Account) return;
     subscribedGroups = m_Account->getGroups();
     for ( QStringList::Iterator it = subscribedGroups.begin(); it != subscribedGroups.end(); ++it ) {
          QCheckListItem *item;
          item = new QCheckListItem( GroupListView, (*it), QCheckListItem::CheckBox );
          item->setOn( true );
     }
 }
 
 void NNTPGroups::storeValues()
 {
     if (!m_Account) return;
     QListViewItemIterator list_it( GroupListView );
     subscribedGroups.clear();
     for ( ; list_it.current(); ++list_it ) {
         if ( ( (QCheckListItem*)list_it.current() )->isOn() ) {
             odebug << list_it.current()->text(0) << oendl; 
             subscribedGroups.append(  list_it.current()->text(0) );
         }
     }
     subscribedGroups+=subscribedGroupsNotListed;
     m_Account->setGroups( subscribedGroups );
 }
diff --git a/noncore/net/mail/opiemail.cpp b/noncore/net/mail/opiemail.cpp
index 0669b5a..5399c3c 100644
--- a/noncore/net/mail/opiemail.cpp
+++ b/noncore/net/mail/opiemail.cpp
@@ -1,115 +1,118 @@
 
 #include "settingsdialog.h"
 #include "opiemail.h"
 #include "editaccounts.h"
 #include "composemail.h"
 #include "mailistviewitem.h"
 #include "viewmail.h"
 #include "selectstore.h"
 #include "selectsmtp.h"
 
-/* OPIE */
 #include <libmailwrapper/smtpwrapper.h>
 #include <libmailwrapper/mailtypes.h>
 #include <libmailwrapper/abstractmail.h>
+/* OPIE */
+#include <opie2/odebug.h>
 #include <qpe/resource.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 
+using namespace Opie::Core;
+
 OpieMail::OpieMail( QWidget *parent, const char *name, WFlags flags )
         : MainWindow( parent, name, WStyle_ContextHelp )
 {
     settings = new Settings();
 
     folderView->populate( settings->getAccounts() );
 }
 
 OpieMail::~OpieMail()
 {
     if (settings) delete settings;
 }
 
 void OpieMail::appMessage(const QCString &msg, const QByteArray &data)
 {
     // copied from old mail2
     if (msg == "writeMail(QString,QString)")
     {
         QDataStream stream(data,IO_ReadOnly);
         QString name, email;
         stream >> name >> email;
         // removing the whitespaces at beginning and end is needed!
         slotwriteMail(name.stripWhiteSpace(),email.stripWhiteSpace());
     }
     else if (msg == "newMail()")
     {
         slotComposeMail();
     }
 }
 
 void OpieMail::slotwriteMail(const QString&name,const QString&email)
 {
     ComposeMail compose( settings, this, 0, true , WStyle_ContextHelp );
     if (!email.isEmpty())
     {
         if (!name.isEmpty())
         {
             compose.setTo("\"" + name + "\"" + " " + "<"+ email + ">");
         }
         else
         {
             compose.setTo(email);
         }
     }
     compose.slotAdjustColumns();
     QPEApplication::execDialog( &compose );
 }
 
 void OpieMail::slotComposeMail()
 {
     odebug << "Compose Mail" << oendl; 
     slotwriteMail(0l,0l);
 }
 
 void OpieMail::slotSendQueued()
 {
     odebug << "Send Queued" << oendl; 
     SMTPaccount *smtp = 0;
 
     QList<Account> list = settings->getAccounts();
     QList<SMTPaccount> smtpList;
     smtpList.setAutoDelete(false);
     Account *it;
     for ( it = list.first(); it; it = list.next() )
     {
         if ( it->getType() == MAILLIB::A_SMTP )
         {
             smtp = static_cast<SMTPaccount *>(it);
             smtpList.append(smtp);
         }
     }
     if (smtpList.count()==0)
     {
         QMessageBox::information(0,tr("Info"),tr("Define a smtp account first"));
         return;
     }
     if (smtpList.count()==1)
     {
         smtp = smtpList.at(0);
     }
     else
     {
         smtp = 0;
         selectsmtp selsmtp;
         selsmtp.setSelectionlist(&smtpList);
         if ( QPEApplication::execDialog( &selsmtp ) == QDialog::Accepted )
         {
             smtp = selsmtp.selected_smtp();
         }
     }
     if (smtp)
     {
         SMTPwrapper * wrap = new SMTPwrapper(smtp);
         if ( wrap->flushOutbox() )
         {
             QMessageBox::information(0,tr("Info"),tr("Mail queue flushed"));
diff --git a/noncore/net/mail/taskbarapplet/mailapplet.cpp b/noncore/net/mail/taskbarapplet/mailapplet.cpp
index cac9048..2fc1d01 100644
--- a/noncore/net/mail/taskbarapplet/mailapplet.cpp
+++ b/noncore/net/mail/taskbarapplet/mailapplet.cpp
@@ -1,104 +1,104 @@
 #include <qpainter.h>
 #include <qtimer.h>
 
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/applnk.h>
-
+#include <opie2/odebug.h>
 #include <opie2/odevice.h>
 
 #include <libmailwrapper/settings.h>
 
 #include "mailapplet.h"
 
 using namespace Opie::Core;
 
 MailApplet::MailApplet( QWidget *parent )
 : QWidget( parent ) {
 
     m_config = new Config( "mail" );
     m_config->setGroup( "Applet" );
 
     setFixedWidth( AppLnk::smallIconSize() );
     setFixedHeight( AppLnk::smallIconSize() );
 
     hide();
 
     m_newMails = 0;
     m_statusMail = 0l;
 
     if ( !m_config->readBoolEntry( "Disabled", false ) ) {
         // delay 5 sec until the whole mail backend gets started .-)
         QTimer::singleShot( 5000, this, SLOT( startup() ) );
     }
     repaint( true );
 }
 
 
 MailApplet::~MailApplet() {
     if ( m_statusMail )
         delete m_statusMail;
     if ( m_config )
         delete m_config;
 }
 
 void MailApplet::paintEvent( QPaintEvent* ) {
     QPainter p( this );
     p.drawPixmap( 0, 0, Resource::loadPixmap( "mail/inbox" ) );
     QFont f( "vera", AppLnk::smallIconSize() );
     QFontMetrics fm( f );
     p.setFont( f );
     p.setPen( Qt::blue );
     p.drawText( AppLnk::smallIconSize()/3, AppLnk::smallIconSize() - 2, QString::number( m_newMails ) );
     return;
 
 }
 
 void MailApplet::mouseReleaseEvent( QMouseEvent* e ) {
     slotClicked();
 }
 
 void MailApplet::slotClicked() {
     QCopEnvelope e( "QPE/System", "execute(QString)" );
     e << QString( "opiemail" );
 
     ODevice *device = ODevice::inst();
     if ( !device-> ledList().isEmpty() ) {
         OLed led = ( device->ledList().contains( Led_Mail ) ) ? Led_Mail : device->ledList()[0];
 
         device->setLedState( led, Led_Off );
     }
 
     if (m_statusMail)
         m_statusMail->reset_status();
 
     hide();
 }
 
 void MailApplet::startup() {
     Settings *settings = new Settings();
     QList<Account> ma = settings->getAccounts();
     m_statusMail = new StatusMail( ma );
     delete settings;
 
     m_intervalMs = m_config->readNumEntry( "CheckEvery", 5 ) * 60000;
     m_intervalTimer = new QTimer();
     m_intervalTimer->start( m_intervalMs );
     connect( m_intervalTimer, SIGNAL( timeout() ), this, SLOT( slotCheck() ) );
 }
 
 void MailApplet::slotCheck() {
     // Check wether the check interval has been changed.
     int newIntervalMs = m_config->readNumEntry( "CheckEvery", 5 ) * 60000;
     if ( newIntervalMs != m_intervalMs ) {
         m_intervalTimer->changeInterval( newIntervalMs );
         m_intervalMs = newIntervalMs;
     }
 
     if (m_statusMail == 0) {
         return;
     }
 
     folderStat stat;
     m_statusMail->check_current_stat( stat );
diff --git a/noncore/net/mail/viewmail.cpp b/noncore/net/mail/viewmail.cpp
index a574ea1..7267bcb 100644
--- a/noncore/net/mail/viewmail.cpp
+++ b/noncore/net/mail/viewmail.cpp
@@ -1,117 +1,120 @@
 #include "composemail.h"
 #include "viewmail.h"
 
 /* OPIE */
 #include <libmailwrapper/settings.h>
 #include <libmailwrapper/abstractmail.h>
 #include <libmailwrapper/mailtypes.h>
 
+#include <opie2/odebug.h>
 #include <opie2/ofiledialog.h>
 #include <qpe/config.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qtextbrowser.h>
 #include <qmessagebox.h>
 #include <qtextstream.h>
 #include <qaction.h>
 #include <qpopupmenu.h>
 #include <qfile.h>
 
 using namespace Opie::Ui;
+using namespace Opie::Core;
+
 AttachItem::AttachItem(QListView * parent,QListViewItem *after, const QString&mime,const QString&desc,const QString&file,
                        const QString&fsize,int num,const QValueList<int>&path)
         : QListViewItem(parent,after),_partNum(num)
 {
     _path=path;
     setText(0, mime);
     setText(1, desc);
     setText(2, file);
     setText(3, fsize);
 }
 
 AttachItem::AttachItem(QListViewItem * parent,QListViewItem *after, const QString&mime,const QString&desc,const QString&file,
                        const QString&fsize,int num,const QValueList<int>&path)
         : QListViewItem(parent,after),_partNum(num)
 {
     _path=path;
     setText(0, mime);
     setText(1, desc);
     setText(2, file);
     setText(3, fsize);
 }
 
 bool AttachItem::isParentof(const QValueList<int>&path)
 {
     /* if not set, then no parent */
     if (path.count()==0||_path.count()==0) return false;
     /* the parent must have one digit less then a child */
     if (path.count()!=_path.count()+1) return false;
     for (unsigned int i=0; i < _path.count();++i)
     {
         if (_path[i]!=path[i]) return false;
     }
     return true;
 }
 
 AttachItem* ViewMail::searchParent(const QValueList<int>&path)
 {
     QListViewItemIterator it( attachments );
     for ( ; it.current(); ++it )
     {
         AttachItem*ati = (AttachItem*)it.current();
         if (ati->isParentof(path)) return ati;
     }
     return 0;
 }
 
 AttachItem* ViewMail::lastChild(AttachItem*parent)
 {
     if (!parent) return 0;
     AttachItem* item = (AttachItem*)parent->firstChild();
     if (!item) return item;
     AttachItem*temp=0;
     while( (temp=(AttachItem*)item->nextSibling()))
     {
         item = temp;
     }
     return item;
 }
 
 void ViewMail::setBody(const RecBodyP&body )
 {
 
     m_body = body;
     m_mail[2] = body->Bodytext();
     attachbutton->setEnabled(body->Parts().count()>0);
     attachments->setEnabled(body->Parts().count()>0);
     if (body->Parts().count()==0)
     {
         return;
     }
     AttachItem * curItem=0;
     AttachItem * parentItem = 0;
     QString type=body->Description()->Type()+"/"+body->Description()->Subtype();
     QString desc,fsize;
     double s = body->Description()->Size();
     int w;
     w=0;
 
     while (s>1024)
     {
         s/=1024;
         ++w;
         if (w>=2) break;
     }
 
     QString q="";
     switch(w)
     {
     case 1:
         q="k";
         break;
     case 2:
         q="M";
         break;
     default:
         break;