Convert net to ODP and QtAUX

70 files changed, 310 insertions, 228 deletions

diff --git a/noncore/net/linphone/main.cpp b/noncore/net/linphone/main.cpp
index 9146fee..6368708 100644
--- a/noncore/net/linphone/main.cpp
+++ b/noncore/net/linphone/main.cpp
@@ -1,22 +1,24 @@
 /***************************************************************************
                         main-opie.cpp  -  description
                              -------------------
     begin                : ven mai 23 19:26:00 CEST 2003
     copyright            : (C) 2003 by Simon Morlat
     email                : simon.morlat@linphone.org
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
-#include <opie/oapplicationfactory.h>
+#include <opie2/oapplicationfactory.h>
 #include "mainwindow.h"
 
+
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<MainWindow> )
 
 
diff --git a/noncore/net/mail/accountitem.cpp b/noncore/net/mail/accountitem.cpp
index 9a09c18..e4bb6c5 100644
--- a/noncore/net/mail/accountitem.cpp
+++ b/noncore/net/mail/accountitem.cpp
@@ -1,244 +1,245 @@
 
 #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>
 #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::OSmartPointer<RecMail> > & )
+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;
 }
 
 RecBody POP3viewItem::fetchBody( const RecMailP &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();
     SETPIX(PIXMAP_POP3FOLDER);
     refresh();
 }
 
 void POP3viewItem::contextMenuSelected(int which)
 {
     switch (which)
     {
     case 0:
         disconnect();
         break;
     case 1:
         setOnOffline();
         break;
     }
 }
 
 POP3folderItem::~POP3folderItem()
 {}
 
 POP3folderItem::POP3folderItem( const FolderP&folderInit, POP3viewItem *parent , QListViewItem*after  )
         : AccountViewItem(folderInit,parent,after )
 {
     pop3 = parent;
     if (folder->getDisplayName().lower()!="inbox")
     {
         setPixmap( 0, PIXMAP_POP3FOLDER );
     }
     else
     {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     }
     setText( 0, folder->getDisplayName() );
 }
 
 void POP3folderItem::refresh(QValueList<RecMailP>&target)
 {
     if (folder->may_select())
         pop3->getWrapper()->listMessages( folder->getName(),target );
 }
 
 RecBody POP3folderItem::fetchBody(const RecMailP&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("Move/Copie all mails",contextName),2);
     }
     return m;
 }
 
 void POP3folderItem::downloadMails()
 {
     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;
     }
 }
 
 /**
  * NNTP Account stuff
  */
 NNTPviewItem::NNTPviewItem( NNTPaccount *a, AccountView *parent )
         : AccountViewItem( parent )
 {
     account = a;
     wrapper = AbstractMail::getWrapper( account );
     //FIXME
     SETPIX(PIXMAP_POP3FOLDER);
 #if 0
     if (!account->getOffline())
     {
         setPixmap( 0,  );
     }
     else
     {
         setPixmap( 0, PIXMAP_OFFLINE );
     }
 #endif
     setText( 0, account->getAccountName() );
     setOpen( true );
 }
 
 NNTPviewItem::~NNTPviewItem()
 {
     delete wrapper;
 }
 
 AbstractMail *NNTPviewItem::getWrapper()
 {
     return wrapper;
 }
 
 void NNTPviewItem::refresh( QValueList<RecMailP> & )
 {
     refresh();
@@ -853,281 +854,281 @@ void MHviewItem::contextMenuSelected(int which)
     case 1:
         createFolder();
         break;
     case 2:
         deleteAllMail(getWrapper(),folder);
         break;
     case 3:
         downloadMails();
         break;
     default:
         break;
     }
 }
 
 MHfolderItem::~MHfolderItem()
 {}
 
 MHfolderItem::MHfolderItem( const FolderP &folderInit, MHviewItem *parent , QListViewItem*after  )
         : AccountViewItem(folderInit, parent,after )
 {
     mbox = parent;
     initName();
 }
 
 MHfolderItem::MHfolderItem(const FolderP& folderInit, MHfolderItem *parent, QListViewItem*after, MHviewItem*master)
         : AccountViewItem(folderInit, parent,after )
 {
     folder = folderInit;
     mbox = master;
     initName();
 }
 
 void MHfolderItem::initName()
 {
     QString bName = folder->getDisplayName();
     if (bName.startsWith("/")&&bName.length()>1)
     {
         bName.replace(0,1,"");
     }
     int pos = bName.findRev("/");
     if (pos > 0)
     {
         bName.replace(0,pos+1,"");
     }
     if (bName.lower() == "outgoing")
     {
         setPixmap( 0, PIXMAP_OUTBOXFOLDER );
     }
     else if (bName.lower() == "inbox")
     {
         setPixmap( 0, PIXMAP_INBOXFOLDER);
     } else if (bName.lower() == "drafts") {
         setPixmap(0, Resource::loadPixmap("inline/edit"));
     } else {
         setPixmap( 0, PIXMAP_MBOXFOLDER );
     }
     setText( 0, bName );
 }
 
 const FolderP&MHfolderItem::getFolder()const
 {
     return folder;
 }
 
 void MHfolderItem::refresh(QValueList<RecMailP>&target)
 {
     if (folder->may_select())
         mbox->getWrapper()->listMessages( folder->getName(),target );
 }
 
 RecBody MHfolderItem::fetchBody(const RecMailP&aMail)
 {
     return mbox->getWrapper()->fetchBody(aMail);
 }
 
 void MHfolderItem::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();
             MHviewItem * 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 * MHfolderItem::getContextMenu()
 {
     QPopupMenu *m = new QPopupMenu(0);
     if (m)
     {
         m->insertItem(QObject::tr("Move/Copie all mails",contextName),2);
         m->insertItem(QObject::tr("Delete all mails",contextName),0);
         m->insertItem(QObject::tr("Create new subfolder",contextName),3);
         m->insertItem(QObject::tr("Delete folder",contextName),1);
     }
     return m;
 }
 
 void MHfolderItem::downloadMails()
 {
     AccountView*bl = mbox->accountView();
     if (!bl) return;
     bl->downloadMails(folder,mbox->getWrapper());
 }
 
 void MHfolderItem::createFolder()
 {
     Newmdirdlg ndirdlg(0,0,true);
     if ( QPEApplication::execDialog( &ndirdlg ) )
     {
         QString ndir = ndirdlg.Newdir();
         if (mbox->getWrapper()->createMbox(ndir,folder))
         {
             QListView*v=listView();
             MHviewItem * 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);
             }
         }
     }
 }
 
 void MHfolderItem::contextMenuSelected(int which)
 {
     switch(which)
     {
     case 0:
         deleteAllMail(mbox->getWrapper(),folder);
         break;
     case 1:
         deleteFolder();
         break;
     case 2:
         downloadMails();
         break;
     case 3:
         createFolder();
         break;
     default:
         break;
     }
 }
 
 bool MHfolderItem::isDraftfolder()
 {
     if (folder && folder->getName()==AbstractMail::defaultLocalfolder()+"/"+AbstractMail::draftFolder()) return true;
     return false;
 }
 
 /**
  * Generic stuff
  */
 
 const QString AccountViewItem::contextName="AccountViewItem";
 
 AccountViewItem::AccountViewItem( AccountView *parent )
         : QListViewItem( parent )
 {
     init();
     m_Backlink = parent;
 }
 
 AccountViewItem::AccountViewItem( QListViewItem *parent)
         : QListViewItem( parent),folder(0)
 {
     init();
 }
 
 AccountViewItem::AccountViewItem( QListViewItem *parent , QListViewItem*after  )
         :QListViewItem( parent,after ),folder(0)
 {
     init();
 }
 
-AccountViewItem::AccountViewItem( const Opie::OSmartPointer<Folder>&folderInit,QListViewItem *parent , QListViewItem*after  )
+AccountViewItem::AccountViewItem( const Opie::Core::OSmartPointer<Folder>&folderInit,QListViewItem *parent , QListViewItem*after  )
        :QListViewItem( parent,after ),folder(folderInit)
 {
     init();
 }
 
 void AccountViewItem::init()
 {
     m_Backlink = 0;
 }
 
 AccountViewItem::~AccountViewItem()
 {
     folder = 0;
 }
 
 AccountView*AccountViewItem::accountView()
 {
     return m_Backlink;
 }
 
 void AccountViewItem::deleteAllMail(AbstractMail*wrapper,const FolderP&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();
         }
     }
 }
 
 void AccountViewItem::removeChilds()
 {
     QListViewItem *child = firstChild();
     while ( child )
     {
         QListViewItem *tmp = child;
         child = child->nextSibling();
         delete tmp;
     }
 }
 
 bool AccountViewItem::matchName(const QString&name)const
 {
     if (!folder) return false;
     return folder->getDisplayName()==name;
 }
 
 
 AccountViewItem*AccountViewItem::findSubItem(const QString&path,AccountViewItem*start)
 {
     AccountViewItem*pitem,*sitem;
     if (!start) pitem = (AccountViewItem*)firstChild();
     else pitem = (AccountViewItem*)start->firstChild();
     while (pitem)
     {
         if (pitem->matchName(path))
         {
             break;
         }
         if (pitem->childCount()>0)
         {
             sitem = findSubItem(path,pitem);
             if (sitem)
             {
                 pitem = sitem;
                 break;
             }
         }
         pitem=(AccountViewItem*)pitem->nextSibling();
     }
     return pitem;
 }
 
 bool AccountViewItem::isDraftfolder()
 {
     return false;
 }
diff --git a/noncore/net/mail/accountitem.h b/noncore/net/mail/accountitem.h
index 276eae0..6cdb260 100644
--- a/noncore/net/mail/accountitem.h
+++ b/noncore/net/mail/accountitem.h
@@ -1,210 +1,210 @@
 #ifndef __ACCOUNT_ITEM
 #define __ACCOUNT_ITEM
 
 #include <qlistview.h>
 #include <qlist.h>
 #include <opie2/osmartpointer.h>
 
 class POP3wrapper;
 class RecMail;
 class RecBody;
 class QPopupMenu;
 class Selectstore;
 class AccountView;
 class POP3account;
 class NNTPaccount;
 class IMAPaccount;
 class AbstractMail;
 class Folder;
 
 class AccountViewItem : public QListViewItem
 {
 
 public:
     AccountViewItem( AccountView *parent );
     AccountViewItem( QListViewItem *parent);
     AccountViewItem( QListViewItem *parent , QListViewItem*after  );
-    AccountViewItem( const Opie::OSmartPointer<Folder>&folderInit,QListViewItem *parent , QListViewItem*after  );
+    AccountViewItem( const Opie::Core::OSmartPointer<Folder>&folderInit,QListViewItem *parent , QListViewItem*after  );
 
     virtual ~AccountViewItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&)=0;
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&)=0;
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&)=0;
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&)=0;
     virtual QPopupMenu * getContextMenu(){return 0;};
     virtual void contextMenuSelected(int){}
     virtual AccountView*accountView();
     virtual bool matchName(const QString&name)const;
     virtual bool isDraftfolder();
 
 protected:
     AccountViewItem*findSubItem(const QString&path,AccountViewItem*start=0);
     virtual void init();
     virtual void removeChilds();
-    virtual void deleteAllMail(AbstractMail*wrapper,const Opie::OSmartPointer<Folder>&f);
+    virtual void deleteAllMail(AbstractMail*wrapper,const Opie::Core::OSmartPointer<Folder>&f);
     static const QString contextName;
     AccountView*m_Backlink;
-    Opie::OSmartPointer<Folder> folder;
+    Opie::Core::OSmartPointer<Folder> folder;
 };
 
 class POP3viewItem : public AccountViewItem
 {
 
 public:
     POP3viewItem( POP3account *a, AccountView *parent );
     virtual ~POP3viewItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&target );
-    virtual RecBody fetchBody( const Opie::OSmartPointer<RecMail> &mail );
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&target );
+    virtual RecBody fetchBody( const Opie::Core::OSmartPointer<RecMail> &mail );
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
 
 protected:
     POP3account *account;
     virtual void refresh();
     AbstractMail *wrapper;
     void disconnect();
     void setOnOffline();
 };
 
 class POP3folderItem : public AccountViewItem
 {
 
 public:
-    POP3folderItem( const Opie::OSmartPointer<Folder>&folder, POP3viewItem *parent , QListViewItem*after  );
+    POP3folderItem( const Opie::Core::OSmartPointer<Folder>&folder, POP3viewItem *parent , QListViewItem*after  );
     virtual ~POP3folderItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&);
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&);
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
 
 protected:
     void downloadMails();
     POP3viewItem *pop3;
 };
 
 
 class NNTPviewItem : public AccountViewItem
 {
 
 public:
     NNTPviewItem( NNTPaccount *a, AccountView *parent );
     virtual ~NNTPviewItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&target );
-    virtual RecBody fetchBody( const Opie::OSmartPointer<RecMail> &mail );
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&target );
+    virtual RecBody fetchBody( const Opie::Core::OSmartPointer<RecMail> &mail );
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
 
 protected:
     NNTPaccount *account;
     virtual void refresh();
     AbstractMail *wrapper;
     void disconnect();
     void setOnOffline();
     void subscribeGroups();
 };
 
 class NNTPfolderItem : public AccountViewItem
 {
 
 public:
-    NNTPfolderItem(const Opie::OSmartPointer<Folder>&folder, NNTPviewItem *parent , QListViewItem*after  );
+    NNTPfolderItem(const Opie::Core::OSmartPointer<Folder>&folder, NNTPviewItem *parent , QListViewItem*after  );
     virtual ~NNTPfolderItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&);
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&);
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
 
 protected:
     void downloadMails();
     NNTPviewItem *nntp;
 };
 
 
 
 class IMAPviewItem : public AccountViewItem
 {
     friend class IMAPfolderItem;
 public:
     IMAPviewItem( IMAPaccount *a, AccountView *parent );
     virtual ~IMAPviewItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&);
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&);
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&);
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
     const QStringList&subFolders();
     virtual void refreshFolders(bool force=false);
     bool offline();
 
 protected:
     virtual void createNewFolder();
     IMAPaccount *account;
     AbstractMail *wrapper;
     QStringList currentFolders;
 };
 
 class IMAPfolderItem : public AccountViewItem
 {
 
 public:
-    IMAPfolderItem( const Opie::OSmartPointer<Folder>&folder, IMAPviewItem *parent , QListViewItem*after  );
-    IMAPfolderItem( const Opie::OSmartPointer<Folder>&folder, IMAPfolderItem *parent , QListViewItem*after, IMAPviewItem *master  );
+    IMAPfolderItem( const Opie::Core::OSmartPointer<Folder>&folder, IMAPviewItem *parent , QListViewItem*after  );
+    IMAPfolderItem( const Opie::Core::OSmartPointer<Folder>&folder, IMAPfolderItem *parent , QListViewItem*after, IMAPviewItem *master  );
     virtual ~IMAPfolderItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&);
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&);
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
     virtual const QString& Delemiter()const;
 protected:
     virtual void createNewFolder();
     virtual void deleteFolder();
     virtual void downloadMails();
     IMAPviewItem *imap;
 };
 
 class MHviewItem : public AccountViewItem
 {
     friend class MHfolderItem;
 
 public:
     MHviewItem( const QString&aMboxPath, AccountView *parent );
     virtual ~MHviewItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&target );
-    virtual RecBody fetchBody( const Opie::OSmartPointer<RecMail> &mail );
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&target );
+    virtual RecBody fetchBody( const Opie::Core::OSmartPointer<RecMail> &mail );
     AbstractMail *getWrapper();
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
     QStringList subFolders();
     virtual void refresh(bool force=false);
 
 protected:
     void downloadMails();
     virtual void createFolder();
     QString m_Path;
     AbstractMail *wrapper;
     QStringList currentFolders;
 };
 
 class MHfolderItem : public AccountViewItem
 {
 
 public:
-    MHfolderItem( const Opie::OSmartPointer<Folder>&folder, MHviewItem *parent , QListViewItem*after  );
-    MHfolderItem( const Opie::OSmartPointer<Folder>&folder, MHfolderItem *parent, QListViewItem*after, MHviewItem*master);
+    MHfolderItem( const Opie::Core::OSmartPointer<Folder>&folder, MHviewItem *parent , QListViewItem*after  );
+    MHfolderItem( const Opie::Core::OSmartPointer<Folder>&folder, MHfolderItem *parent, QListViewItem*after, MHviewItem*master);
     virtual ~MHfolderItem();
-    virtual void refresh(QValueList<Opie::OSmartPointer<RecMail> >&);
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&);
+    virtual void refresh(QValueList<Opie::Core::OSmartPointer<RecMail> >&);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&);
     virtual QPopupMenu * getContextMenu();
     virtual void contextMenuSelected(int);
-    virtual const Opie::OSmartPointer<Folder>&getFolder()const;
+    virtual const Opie::Core::OSmartPointer<Folder>&getFolder()const;
     virtual bool isDraftfolder();
 
 protected:
     void downloadMails();
     virtual void createFolder();
     virtual void deleteFolder();
     void initName();
     MHviewItem *mbox;
 };
 
 #endif
diff --git a/noncore/net/mail/accountview.cpp b/noncore/net/mail/accountview.cpp
index 26107ff..811e57a 100644
--- a/noncore/net/mail/accountview.cpp
+++ b/noncore/net/mail/accountview.cpp
@@ -1,175 +1,176 @@
 
 #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>
 #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);
             qDebug( "added IMAP " + imap->getAccountName() );
             imapAccounts.append(new IMAPviewItem( imap, this ));
         }
         else if ( it->getType() == MAILLIB::A_POP3 )
         {
             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 );
         }
          else if ( it->getType() == MAILLIB::A_NNTP )
         {
             NNTPaccount *nntp = static_cast<NNTPaccount *>(it);
             qDebug( "added NNTP " + nntp->getAccountName() );
             /* must not be hold 'cause it isn't required */
             (void) new NNTPviewItem( nntp, this );
        }
      }
 }
 
 void AccountView::refresh(QListViewItem *item)
 {
 
     qDebug("AccountView refresh...");
     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;
     QValueList<RecMailP> headerlist;
     AccountViewItem *view = static_cast<AccountViewItem *>(m_currentItem);
     view->refresh(headerlist);
     emit refreshMailview(headerlist);
 }
 
 void AccountView::refreshAll()
 {
 }
 
 RecBody AccountView::fetchBody(const RecMailP&aMail)
 {
     QListViewItem*item = selectedItem ();
     if (!item) return RecBody();
     AccountViewItem *view = static_cast<AccountViewItem *>(item);
     return view->fetchBody(aMail);
 }
 
 void AccountView::setupFolderselect(Selectstore*sels)
 {
     QPEApplication::showDialog( sels );
     QStringList sFolders;
     unsigned int i = 0;
     for (i=0; i < mhAccounts.count();++i)
     {
         mhAccounts[i]->refresh(false);
         sFolders = mhAccounts[i]->subFolders();
         sels->addAccounts(mhAccounts[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(const FolderP&fromFolder,AbstractMail*fromWrapper)
 {
     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;
     }
     if (sels.newFolder() && !targetMail->createMbox(targetFolder))
     {
         QMessageBox::critical(0,tr("Error creating new Folder"),
                               tr("<center>Error while creating<br>new folder - breaking.</center>"));
         return;
     }
     qDebug("Targetfolder: %s",targetFolder.latin1());
     qDebug("Fromfolder: %s",fromFolder->getName().latin1());
     fromWrapper->mvcpAllMails(fromFolder,targetFolder,targetMail,sels.moveMails());
     refreshCurrent();
 }
 
 bool AccountView::currentisDraft()
 {
     AccountViewItem *view = static_cast<AccountViewItem *>(currentItem());
     if (!view) return false;
     return view->isDraftfolder();
 }
diff --git a/noncore/net/mail/accountview.h b/noncore/net/mail/accountview.h
index d236058..b082b1f 100644
--- a/noncore/net/mail/accountview.h
+++ b/noncore/net/mail/accountview.h
@@ -1,45 +1,45 @@
 #ifndef ACCOUNTVIEW_H
 #define ACCOUNTVIEW_H
 
 #include <qlistview.h>
 #include <qlist.h>
 #include <opie2/osmartpointer.h>
 #include <libmailwrapper/mailtypes.h>
 
 class Selectstore;
 class Folder;
 class AbstractMail;
 class Account;
 class IMAPviewItem;
 class MHviewItem;
 
 class AccountView : public QListView
 {
     Q_OBJECT
 
 public:
     AccountView( QWidget *parent = 0, const char *name = 0, WFlags flags = 0 );
     virtual ~AccountView();
     virtual void populate( QList<Account> list );
-    virtual RecBody fetchBody(const Opie::OSmartPointer<RecMail>&aMail);
-    virtual void downloadMails(const Opie::OSmartPointer<Folder>&fromFolder,AbstractMail*fromWrapper);
+    virtual RecBody fetchBody(const Opie::Core::OSmartPointer<RecMail>&aMail);
+    virtual void downloadMails(const Opie::Core::OSmartPointer<Folder>&fromFolder,AbstractMail*fromWrapper);
     virtual bool currentisDraft();
 
 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(const QValueList<RecMailP>& );
 
 protected:
     QListViewItem* m_currentItem;
     QValueList<IMAPviewItem*> imapAccounts;
     QValueList<MHviewItem*> mhAccounts;
 };
 
 #endif
diff --git a/noncore/net/mail/composemail.cpp b/noncore/net/mail/composemail.cpp
index 74ccc7b..5bc2883 100644
--- a/noncore/net/mail/composemail.cpp
+++ b/noncore/net/mail/composemail.cpp
@@ -1,300 +1,302 @@
 #include <qt.h>
 
 #include <opie2/ofiledialog.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 );
 }
 
 void ComposeMail::setInReplyTo( const QString & messageId )
 {
     m_replyid = messageId;
 }
 
 void ComposeMail::setMessage( const QString & text )
 {
   message->setText( text );
 }
 
 
 void ComposeMail::pickAddressTo()
 {
     pickAddress( toLine );
 }
 
 void ComposeMail::pickAddressCC()
 {
     pickAddress( ccLine );
 }
 
 void ComposeMail::pickAddressBCC()
 {
     pickAddress( bccLine );
 }
 
 void ComposeMail::pickAddressReply()
 {
     pickAddress( replyLine );
 }
 
 void ComposeMail::fillValues( int )
 {
 #if 0
     SMTPaccount *smtp = smtpAccounts.at( current );
     ccLine->clear();
     if ( smtp->getUseCC() ) {
         ccLine->setText( smtp->getCC() );
     }
     bccLine->clear();
     if ( smtp->getUseBCC() ) {
         bccLine->setText( smtp->getBCC() );
     }
     replyLine->clear();
     if ( smtp->getUseReply() ) {
         replyLine->setText( smtp->getReply() );
     }
     sigMultiLine->setText( smtp->getSignature() );
 #endif
 }
 
 void ComposeMail::slotAdjustColumns()
 {
     int currPage = tabWidget->currentPageIndex();
 
     tabWidget->showPage( attachTab );
     attList->setColumnWidth( 0, attList->visibleWidth() - 80 );
     attList->setColumnWidth( 1, 80 );
 
     tabWidget->setCurrentPage( currPage );
 }
 
 void ComposeMail::addAttachment()
 {
-    DocLnk lnk = Opie::OFileDialog::getOpenFileName( 1, "/" );
+    DocLnk lnk = OFileDialog::getOpenFileName( 1, "/" );
     if ( !lnk.name().isEmpty() ) {
         Attachment *att = new Attachment( lnk );
         (void) new AttachViewItem( attList, att );
     }
 }
 
 void ComposeMail::removeAttachment()
 {
     if ( !attList->currentItem() ) {
         QMessageBox::information( this, tr( "Error" ),
                                   tr( "<p>Please select a File.</p>" ),
                                   tr( "Ok" ) );
     } else {
         attList->takeItem( attList->currentItem() );
     }
 }
 
 void ComposeMail::accept()
 {
     if ( checkBoxLater->isChecked() ) {
         qDebug(  "Send later" );
     }
 
 #if 0
     qDebug( "Sending Mail with " +
             smtpAccounts.at( smtpAccountBox->currentItem() )->getAccountName() );
 #endif
-    Opie::OSmartPointer<Mail> mail=new Mail;
+    Opie::Core::OSmartPointer<Mail> mail=new Mail;
 
     SMTPaccount *smtp = smtpAccounts.at( smtpAccountBox->currentItem() );
     mail->setMail(fromBox->currentText());
 
     if ( !toLine->text().isEmpty() ) {
         mail->setTo( toLine->text() );
     } else {
         QMessageBox::warning(0,tr("Sending mail"),
             tr("No Receiver spezified" ) );
         return;
     }
     mail->setName(senderNameEdit->text());
     mail->setCC( ccLine->text() );
     mail->setBCC( bccLine->text() );
     mail->setReply( replyLine->text() );
     mail->setSubject( subjectLine->text() );
     if (!m_replyid.isEmpty()) {
         QStringList ids;
         ids.append(m_replyid);
         mail->setInreply(ids);
     }
     QString txt = message->text();
     if ( !sigMultiLine->text().isEmpty() ) {
         txt.append( "\n--\n" );
         txt.append( sigMultiLine->text() );
     }
     mail->setMessage( txt );
     AttachViewItem *it = (AttachViewItem *) attList->firstChild();
     while ( it != NULL ) {
         mail->addAttachment( it->getAttachment() );
         it = (AttachViewItem *) it->nextSibling();
     }
 
     SMTPwrapper wrapper( smtp );
     wrapper.sendMail( mail,checkBoxLater->isChecked() );
 
     QDialog::accept();
 }
 
 void ComposeMail::reject()
 {
     int yesno = QMessageBox::warning(0,tr("Store message"),
                                      tr("Store message into drafts?"),
                                      tr("Yes"),
                                      tr("No"),QString::null,0,1);
 
     if (yesno == 0) {
-        Opie::OSmartPointer<Mail> mail=new Mail();
+        Opie::Core::OSmartPointer<Mail> mail=new Mail();
         mail->setMail(fromBox->currentText());
         mail->setTo( toLine->text() );
         mail->setName(senderNameEdit->text());
         mail->setCC( ccLine->text() );
         mail->setBCC( bccLine->text() );
         mail->setReply( replyLine->text() );
         mail->setSubject( subjectLine->text() );
         if (!m_replyid.isEmpty()) {
             QStringList ids;
             ids.append(m_replyid);
             mail->setInreply(ids);
         }
         QString txt = message->text();
         if ( !sigMultiLine->text().isEmpty() ) {
             txt.append( "\n--\n" );
             txt.append( sigMultiLine->text() );
         }
         qDebug(txt);
         mail->setMessage( txt );
 
         /* only use the default drafts folder name! */
         Storemail wrapper(AbstractMail::draftFolder());
         wrapper.storeMail(mail);
 
         AttachViewItem *it = (AttachViewItem *) attList->firstChild();
         /* attachments we will ignore! */
         if ( it != NULL ) {
             QMessageBox::warning(0,tr("Store message"),
                 tr("<center>Attachments will not be stored in \"Draft\" folder</center>"));
         }
     }
     QDialog::reject();
 }
 
 ComposeMail::~ComposeMail()
 {
 }
 
 void ComposeMail::reEditMail(const RecMailP&current)
 {
     RecMailP data = current;
     message->setText(data->Wrapper()->fetchBody(current).Bodytext());
     subjectLine->setText( data->getSubject());
     toLine->setText(data->To().join(","));
     ccLine->setText(data->CC().join(","));
     bccLine->setText(data->Bcc().join(","));
     replyLine->setText(data->Replyto());
 }
 
 AttachViewItem::AttachViewItem( QListView *parent, Attachment *att )
     : QListViewItem( parent )
 {
     attachment = att;
     qDebug( att->getMimeType() );
     setPixmap( 0, attachment->getDocLnk().pixmap().isNull() ?
                   Resource::loadPixmap( "UnknownDocument-14" ) :
                   attachment->getDocLnk().pixmap() );
     setText( 0, att->getName().isEmpty() ? att->getFileName() : att->getName() );
     setText( 1, QString::number( att->getSize() ) );
 }
 
diff --git a/noncore/net/mail/composemail.h b/noncore/net/mail/composemail.h
index c12eb30..4693927 100644
--- a/noncore/net/mail/composemail.h
+++ b/noncore/net/mail/composemail.h
@@ -1,81 +1,81 @@
 #ifndef COMPOSEMAIL_H
 #define COMPOSEMAIL_H
 
 #include <qlineedit.h>
 #include <qlistview.h>
 
 #include "composemailui.h"
 #include "addresspickerui.h"
 #include <libmailwrapper/settings.h>
 #include <libmailwrapper/mailwrapper.h>
 
 class RecMail;
 
 #include <opie2/osmartpointer.h>
 
 class AddressPicker : public AddressPickerUI
 {
     Q_OBJECT
 
 public:
     AddressPicker( QWidget *parent = 0, const char *name = 0, bool modal = false, WFlags flags = 0 );
     static QString getNames();
 
 protected:
     QString selectedNames;
     void accept();
 
 };
 
 class RecMail;
 
 class ComposeMail : public ComposeMailUI
 {
     Q_OBJECT
 
 public:
     ComposeMail( Settings *s, QWidget *parent = 0, const char *name = 0, bool modal = false, WFlags flags = 0 );
     virtual ~ComposeMail();
 
-    void reEditMail(const Opie::OSmartPointer<RecMail>&current);
+    void reEditMail(const Opie::Core::OSmartPointer<RecMail>&current);
 
 public slots:
     void slotAdjustColumns();
 
     void setTo( const QString & to );
     void setSubject( const QString & subject );
     void setInReplyTo( const QString & messageId );
     void setMessage( const QString & text );
 
 protected slots:
     void accept();
     void reject();
 
 private slots:
     void fillValues( int current );
     void pickAddress( QLineEdit *line );
     void pickAddressTo();
     void pickAddressCC();
     void pickAddressBCC();
     void pickAddressReply();
     void addAttachment();
     void removeAttachment();
 
 protected:
     Settings *settings;
     QList<SMTPaccount> smtpAccounts;
     QString m_replyid;
 };
 
 class AttachViewItem : public QListViewItem
 {
 public:
     AttachViewItem( QListView *parent, Attachment *att );
     Attachment *getAttachment() { return attachment; }
 
 private:
     Attachment *attachment;
 
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/abstractmail.cpp b/noncore/net/mail/libmailwrapper/abstractmail.cpp
index 68a7a4d..6bebb7b 100644
--- a/noncore/net/mail/libmailwrapper/abstractmail.cpp
+++ b/noncore/net/mail/libmailwrapper/abstractmail.cpp
@@ -1,167 +1,168 @@
 #include "abstractmail.h"
 #include "imapwrapper.h"
 #include "pop3wrapper.h"
 #include "nntpwrapper.h"
 #include "mhwrapper.h"
 #include "mailtypes.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)
 {
     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;
     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);*/
     //qDebug("Input: %s",text);
     if (err == MAILIMF_NO_ERROR && res && strlen(res)) {
 //        result = QString(res);
 //        qDebug("Res: %s, length: %i",res,strlen(res));
     }
     if (res) free(res);
     return result;
 }
 
 /* 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 FolderP&,const QString& ,bool)
 {
     return 0;
 }
 
 QString AbstractMail::defaultLocalfolder()
 {
     QString f = getenv( "HOME" );
     f += "/Applications/opiemail/localmail";
     return f;
 }
 
 QString AbstractMail::draftFolder()
 {
     return QString("Drafts");
 }
 
 /* temporary - will be removed when implemented in all classes */
-void AbstractMail::deleteMails(const QString &,const QValueList<Opie::OSmartPointer<RecMail> > &)
+void AbstractMail::deleteMails(const QString &,const QValueList<Opie::Core::OSmartPointer<RecMail> > &)
 {
 }
 
 void AbstractMail::mvcpAllMails(const FolderP&fromFolder,
     const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     QValueList<RecMailP> t;
     listMessages(fromFolder->getName(),t);
     encodedString*st = 0;
     while (t.count()>0) {
         RecMailP r = (*t.begin());
         st = fetchRawBody(r);
         if (st) {
             targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder);
             delete st;
         }
         t.remove(t.begin());
     }
     if (moveit) {
         deleteAllMail(fromFolder);
     }
 }
 
 void AbstractMail::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     encodedString*st = 0;
     st = fetchRawBody(mail);
     if (st) {
         targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder);
         delete st;
     }
     if (moveit) {
         deleteMail(mail);
     }
 }
diff --git a/noncore/net/mail/libmailwrapper/abstractmail.h b/noncore/net/mail/libmailwrapper/abstractmail.h
index b03d757..2d55c83 100644
--- a/noncore/net/mail/libmailwrapper/abstractmail.h
+++ b/noncore/net/mail/libmailwrapper/abstractmail.h
@@ -1,72 +1,72 @@
 #ifndef __abstract_mail_
 #define __abstract_mail_
 
 #include "maildefines.h"
 
 #include "settings.h"
 
 #include <qobject.h>
 #include <opie2/osmartpointer.h>
 #include "mailtypes.h"
 
 class IMAPwrapper;
 class POP3wrapper;
 class Folder;
 class encodedString;
 struct folderStat;
 
 class AbstractMail:public QObject
 {
     Q_OBJECT
 public:
     AbstractMail(){};
     virtual ~AbstractMail(){}
-    virtual QValueList<Opie::OSmartPointer<Folder> >* listFolders()=0;
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders()=0;
     virtual void listMessages(const QString & mailbox,QValueList<RecMailP>&target )=0;
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX")=0;
     virtual RecBody fetchBody(const RecMailP&mail)=0;
     virtual QString fetchTextPart(const RecMailP&mail,const RecPart&part)=0;
     virtual encodedString* fetchDecodedPart(const RecMailP&mail,const RecPart&part)=0;
     virtual encodedString* fetchRawPart(const RecMailP&mail,const RecPart&part)=0;
     virtual encodedString* fetchRawBody(const RecMailP&mail)=0;
 
     virtual void deleteMail(const RecMailP&mail)=0;
     virtual void answeredMail(const RecMailP&mail)=0;
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&)=0;
-    virtual void deleteMails(const QString & FolderName,const QValueList<Opie::OSmartPointer<RecMail> >&target);
-    virtual int deleteMbox(const Opie::OSmartPointer<Folder>&)=0;
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&)=0;
+    virtual void deleteMails(const QString & FolderName,const QValueList<Opie::Core::OSmartPointer<RecMail> >&target);
+    virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&)=0;
     virtual void storeMessage(const char*msg,size_t length, const QString&folder)=0;
 
-    virtual void mvcpAllMails(const Opie::OSmartPointer<Folder>&fromFolder,
+    virtual void mvcpAllMails(const Opie::Core::OSmartPointer<Folder>&fromFolder,
         const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
     virtual void mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
 
     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 Opie::OSmartPointer<Folder>&parentfolder=0,
+    virtual int createMbox(const QString&,const Opie::Core::OSmartPointer<Folder>&parentfolder=0,
         const QString& delemiter="/",bool getsubfolder=false);
     virtual void logout()=0;
 
     static AbstractMail* getWrapper(IMAPaccount *a);
     static AbstractMail* getWrapper(POP3account *a);
     static AbstractMail* getWrapper(NNTPaccount *a);
     /* mbox only! */
     static AbstractMail* getWrapper(const QString&a,const QString&name="Local Folders");
     static AbstractMail* getWrapper(Account*a);
 
     static QString defaultLocalfolder();
     static QString draftFolder();
 
     virtual MAILLIB::ATYPE 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/generatemail.cpp b/noncore/net/mail/libmailwrapper/generatemail.cpp
index cb7ccc0..cb58d82 100644
--- a/noncore/net/mail/libmailwrapper/generatemail.cpp
+++ b/noncore/net/mail/libmailwrapper/generatemail.cpp
@@ -1,467 +1,468 @@
 #include "generatemail.h"
 #include "mailwrapper.h"
 
 #include <libetpan/libetpan.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);
                     qDebug("Appended %s",s.latin1());
                 }
                 // !!!! this is a MUST BE!
                 startpos = ++i;
             }
             break;
         default:
             break;
         }
     }
     s = addr.mid(startpos,i-startpos);
     if (!s.isEmpty()) {
         list.append(s);
         qDebug("Appended %s",s.latin1());
     }
     QStringList::Iterator it;
     for ( it = list.begin(); it != list.end(); it++ ) {
         int err = mailimf_address_list_add_parse( addresses, (char*)(*it).latin1() );
         if ( err != MAILIMF_NO_ERROR ) {
             qDebug( "Error parsing" );
             qDebug( *it );
         } else {
             qDebug( "Parse success! %s",(*it).latin1());
         }
     }
     return addresses;
 }
 
 mailmime *Generatemail::buildFilePart(const QString&filename,const QString&mimetype,const QString&TextContent ) {
     mailmime * filePart = 0;
     mailmime_fields * fields = 0;
     mailmime_content * content = 0;
     mailmime_parameter * param = 0;
     char*name = 0;
     char*file = 0;
     int err;
 
     int pos = filename.findRev( '/' );
 
     if (filename.length()>0) {
         QString tmp = filename.right( filename.length() - ( pos + 1 ) );
         name = strdup( tmp.latin1() );        // just filename
         file = strdup( filename.latin1() );   // full name with path
     }
 
     int disptype = MAILMIME_DISPOSITION_TYPE_ATTACHMENT;
     int mechanism = MAILMIME_MECHANISM_BASE64;
 
     if ( mimetype.startsWith( "text/" ) ) {
         param = mailmime_parameter_new( strdup( "charset" ),
                                         strdup( "iso-8859-1" ) );
         mechanism = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
     }
 
     fields = mailmime_fields_new_filename(
                  disptype, name,
                  mechanism );
     content = mailmime_content_new_with_str( (char*)mimetype.latin1() );
     if (content!=0 && fields != 0) {
         if (param) {
             clist_append(content->ct_parameters,param);
             param = 0;
         }
         if (filename.length()>0) {
             QFileInfo f(filename);
             param = mailmime_parameter_new(strdup("name"),strdup(f.fileName().latin1()));
             clist_append(content->ct_parameters,param);
             param = 0;
         }
         filePart = mailmime_new_empty( content, fields );
     }
     if (filePart) {
         if (filename.length()>0) {
             err = mailmime_set_body_file( filePart, file );
         } else {
             err = mailmime_set_body_text(filePart,strdup(TextContent.data()),TextContent.length());
         }
         if (err != MAILIMF_NO_ERROR) {
             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 Generatemail::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 *Generatemail::buildTxtPart(const QString&str ) {
     mailmime *txtPart;
     mailmime_fields *fields;
     mailmime_content *content;
     mailmime_parameter *param;
     int err;
 
     param = mailmime_parameter_new( strdup( "charset" ),
                                     strdup( "iso-8859-1" ) );
     if ( param == NULL )
         goto err_free;
 
     content = mailmime_content_new_with_str( "text/plain" );
     if ( content == NULL )
         goto err_free_param;
 
     err = clist_append( content->ct_parameters, param );
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_content;
 
     fields = mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT);
     if ( fields == NULL )
         goto err_free_content;
 
     txtPart = mailmime_new_empty( content, fields );
     if ( txtPart == NULL )
         goto err_free_fields;
 
     err = mailmime_set_body_text( txtPart, (char*)str.data(), str.length() );
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_txtPart;
 
     return txtPart;     // Success :)
 
 err_free_txtPart:
     mailmime_free( txtPart );
 err_free_fields:
     mailmime_fields_free( fields );
 err_free_content:
     mailmime_content_free( content );
 err_free_param:
     mailmime_parameter_free( param );
 err_free:
     qDebug( "buildTxtPart - error" );
 
     return NULL;        // Error :(
 }
 
 mailimf_mailbox *Generatemail::newMailbox(const QString&name, const QString&mail ) {
     return mailimf_mailbox_new( strdup( name.latin1() ),
                                 strdup( mail.latin1() ) );
 }
 
-mailimf_fields *Generatemail::createImfFields(const Opie::OSmartPointer<Mail>&mail )
+mailimf_fields *Generatemail::createImfFields(const Opie::Core::OSmartPointer<Mail>&mail )
 {
     mailimf_fields *fields = NULL;
     mailimf_field *xmailer = NULL;
     mailimf_mailbox *sender=0,*fromBox=0;
     mailimf_mailbox_list *from=0;
     mailimf_address_list *to=0, *cc=0, *bcc=0, *reply=0;
     clist*in_reply_to = 0;
     char *subject = strdup( mail->getSubject().latin1() );
     int err;
     int res = 1;
 
     sender = newMailbox( mail->getName(), mail->getMail() );
     if ( sender == NULL ) {
         res = 0;
     }
 
     if (res) {
         fromBox = newMailbox( mail->getName(), mail->getMail() );
     }
     if ( fromBox == NULL ) {
         res = 0;
     }
 
     if (res) {
         from = mailimf_mailbox_list_new_empty();
     }
     if ( from == NULL ) {
         res = 0;
     }
 
     if (res && from) {
         err = mailimf_mailbox_list_add( from, fromBox );
         if ( err != MAILIMF_NO_ERROR ) {
             res = 0;
         }
     }
 
     if (res) to = parseAddresses( mail->getTo() );
     if (res) cc = parseAddresses( mail->getCC() );
     if (res) bcc = parseAddresses( mail->getBCC() );
     if (res) reply = parseAddresses( mail->getReply() );
 
     if (res && mail->Inreply().count()>0) {
         in_reply_to = clist_new();
         char*c_reply;
         unsigned int nsize = 0;
         for (QStringList::ConstIterator it=mail->Inreply().begin();
              it != mail->Inreply().end();++it) {
             if ((*it).isEmpty())
                 continue;
             QString h((*it));
             while (h.length()>0 && h[0]=='<') {
                 h.remove(0,1);
             }
             while (h.length()>0 && h[h.length()-1]=='>') {
                 h.remove(h.length()-1,1);
             }
             if (h.isEmpty()) continue;
             nsize = strlen(h.latin1());
             /* yes! must be malloc! */
             c_reply = (char*)malloc( (nsize+1)*sizeof(char));
             memset(c_reply,0,nsize+1);
             memcpy(c_reply,h.latin1(),nsize);
             clist_append(in_reply_to,c_reply);
             qDebug("In reply to: %s",c_reply);
         }
     }
 
     if (res) {
         fields = mailimf_fields_new_with_data( from, sender, reply, to, cc, bcc,
                                            in_reply_to, NULL, subject );
         if ( fields == NULL ) {
             qDebug("Error creating mailimf fields");
             res = 0;
         }
     }
     if (res) xmailer = mailimf_field_new_custom( strdup( "User-Agent" ),
                                         strdup( USER_AGENT ) );
     if ( xmailer == NULL ) {
         res = 0;
     } else {
         err = mailimf_fields_add( fields, xmailer );
         if ( err != MAILIMF_NO_ERROR ) {
             res = 0;
         }
     }
     if (!res ) {
         if (xmailer) {
             mailimf_field_free( xmailer );
             xmailer = NULL;
         }
         if (fields) {
             mailimf_fields_free( fields );
             fields = NULL;
         } else {
             if (reply)
                 mailimf_address_list_free( reply );
             if (bcc)
                 mailimf_address_list_free( bcc );
             if (cc)
                 mailimf_address_list_free( cc );
             if (to)
                 mailimf_address_list_free( to );
             if (fromBox) {
                 mailimf_mailbox_free( fromBox );
             } else if (from) {
                 mailimf_mailbox_list_free( from );
             }
             if (sender) {
                 mailimf_mailbox_free( sender );
             }
             if (subject) {
                 free( subject );
             }
         }
     }
     return fields;
 }
 
-mailmime *Generatemail::createMimeMail(const Opie::OSmartPointer<Mail> &mail ) {
+mailmime *Generatemail::createMimeMail(const Opie::Core::OSmartPointer<Mail> &mail ) {
     mailmime *message, *txtPart;
     mailimf_fields *fields;
     int err;
 
     fields = createImfFields( mail );
     if ( fields == NULL )
         goto err_free;
 
     message = mailmime_new_message_data( NULL );
     if ( message == NULL )
         goto err_free_fields;
 
     mailmime_set_imf_fields( message, fields );
 
     txtPart = buildTxtPart( mail->getMessage() );
 
     if ( txtPart == NULL )
         goto err_free_message;
 
     err = mailmime_smart_add_part( message, txtPart );
     if ( err != MAILIMF_NO_ERROR )
         goto err_free_txtPart;
 
     addFileParts( message, mail->getAttachments() );
 
     return message;         // Success :)
 
 err_free_txtPart:
     mailmime_free( txtPart );
 err_free_message:
     mailmime_free( message );
 err_free_fields:
     mailimf_fields_free( fields );
 err_free:
     qDebug( "createMimeMail: error" );
 
     return NULL;            // Error :(
 }
 
 clist *Generatemail::createRcptList( mailimf_fields *fields ) {
     clist *rcptList;
     mailimf_field *field;
 
     rcptList = esmtp_address_list_new();
 
     field = getField( fields, MAILIMF_FIELD_TO );
     if ( field && (field->fld_type == MAILIMF_FIELD_TO)
             && field->fld_data.fld_to->to_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_to->to_addr_list );
     }
 
     field = getField( fields, MAILIMF_FIELD_CC );
     if ( field && (field->fld_type == MAILIMF_FIELD_CC)
             && field->fld_data.fld_cc->cc_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_cc->cc_addr_list );
     }
 
     field = getField( fields, MAILIMF_FIELD_BCC );
     if ( field && (field->fld_type == MAILIMF_FIELD_BCC)
             && field->fld_data.fld_bcc->bcc_addr_list ) {
         addRcpts( rcptList, field->fld_data.fld_bcc->bcc_addr_list );
     }
 
     return rcptList;
 }
diff --git a/noncore/net/mail/libmailwrapper/generatemail.h b/noncore/net/mail/libmailwrapper/generatemail.h
index c246a2a..a767b61 100644
--- a/noncore/net/mail/libmailwrapper/generatemail.h
+++ b/noncore/net/mail/libmailwrapper/generatemail.h
@@ -1,46 +1,46 @@
 #ifndef __GENERATE_MAIL_H
 #define __GENERATE_MAIL_H
 
 #include <qpe/applnk.h>
 
 #include <qobject.h>
 #include <libetpan/clist.h>
 
 #include <opie2/osmartpointer.h>
 
 class Mail;
 class RecMail;
 class Attachment;
 struct mailimf_fields;
 struct mailimf_field;
 struct mailimf_mailbox;
 struct mailmime;
 struct mailimf_address_list;
 class progressMailSend;
 struct mailsmtp;
 
 class Generatemail : public QObject
 {
     Q_OBJECT
 public:
     Generatemail();
     virtual ~Generatemail();
 
 protected:
     static void addRcpts( clist *list, mailimf_address_list *addr_list );
     static char *getFrom( mailmime *mail );
     static char *getFrom( mailimf_field *ffrom);
     static mailimf_field *getField( mailimf_fields *fields, int type );
     mailimf_address_list *parseAddresses(const QString&addr );
     void addFileParts( mailmime *message,const QList<Attachment>&files );
     mailmime *buildFilePart(const QString&filename,const QString&mimetype,const QString&content);
     mailmime *buildTxtPart(const QString&str );
     mailimf_mailbox *newMailbox(const QString&name,const QString&mail );
-    mailimf_fields *createImfFields(const Opie::OSmartPointer<Mail> &mail );
-    mailmime *createMimeMail(const Opie::OSmartPointer<Mail>&mail );
+    mailimf_fields *createImfFields(const Opie::Core::OSmartPointer<Mail> &mail );
+    mailmime *createMimeMail(const Opie::Core::OSmartPointer<Mail>&mail );
     clist *createRcptList( mailimf_fields *fields );
 
     static const char* USER_AGENT;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/genericwrapper.cpp b/noncore/net/mail/libmailwrapper/genericwrapper.cpp
index ee2c8cd..f428415 100644
--- a/noncore/net/mail/libmailwrapper/genericwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/genericwrapper.cpp
@@ -1,196 +1,197 @@
 #include "genericwrapper.h"
 #include <libetpan/libetpan.h>
 #include "mailtypes.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(RecPart&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(RecPart&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));
         }
     }
 }
 
 QString Genericwrapper::getencoding(mailmime_mechanism*aEnc)
 {
     QString enc="7bit";
     if (!aEnc) return enc;
     switch(aEnc->enc_type) {
     case MAILMIME_MECHANISM_7BIT:
         enc = "7bit";
         break;
     case MAILMIME_MECHANISM_8BIT:
         enc = "8bit";
         break;
     case MAILMIME_MECHANISM_BINARY:
         enc = "binary";
         break;
     case MAILMIME_MECHANISM_QUOTED_PRINTABLE:
         enc = "quoted-printable";
         break;
     case MAILMIME_MECHANISM_BASE64:
         enc = "base64";
         break;
     case MAILMIME_MECHANISM_TOKEN:
     default:
         if (aEnc->enc_token) {
             enc = QString(aEnc->enc_token);
         }
         break;
     }
     return enc;
 }
 
 void Genericwrapper::traverseBody(RecBody&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rec,int current_count)
 {
     if (current_rec >= 10) {
         qDebug("too deep recursion!");
     }
     if (!message || !mime) {
         return;
     }
     int r;
     char*data = 0;
     size_t len;
     clistiter * cur = 0;
     QString b;
     RecPart part;
 
     switch (mime->mm_type) {
     case MAILMIME_SINGLE:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         r = mailmessage_fetch_section(message,mime,&data,&len);
         part.setSize(len);
         part.setPositionlist(countlist);
         b = gen_attachment_id();
         part.setIdentifier(b);
         fillSingleBody(part,message,mime);
         if (part.Type()=="text" && target.Bodytext().isNull()) {
             encodedString*rs = new encodedString();
             rs->setContent(data,len);
             encodedString*res = decode_String(rs,part.Encoding());
             if (countlist.count()>2) {
                 bodyCache[b]=rs;
                 target.addPart(part);
             } else {
                 delete rs;
             }
             b = QString(res->Content());
             delete res;
             target.setBodytext(b);
             target.setDescription(part);
         } else {
             bodyCache[b]=new encodedString(data,len);
             target.addPart(part);
         }
     }
     break;
     case MAILMIME_MULTIPLE:
     {
         unsigned int ccount = 1;
         mailmime*cbody=0;
         QValueList<int>countlist = recList;
         for (cur = clist_begin(mime->mm_data.mm_multipart.mm_mp_list) ; cur != NULL ; cur = clist_next(cur)) {
             cbody = (mailmime*)clist_content(cur);
             if (cbody->mm_type==MAILMIME_MULTIPLE) {
                 RecPart targetPart;
                 targetPart.setType("multipart");
                 countlist.append(current_count);
                 targetPart.setPositionlist(countlist);
                 target.addPart(targetPart);
             }
             traverseBody(target,message, cbody,countlist,current_rec+1,ccount);
             if (cbody->mm_type==MAILMIME_MULTIPLE) {
                 countlist = recList;
@@ -198,278 +199,278 @@ void Genericwrapper::traverseBody(RecBody&target,mailmessage*message,mailmime*mi
             ++ccount;
         }
     }
     break;
     case MAILMIME_MESSAGE:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         /* the own header is always at recursion 0 - we don't need that */
         if (current_rec > 0) {
             part.setPositionlist(countlist);
             r = mailmessage_fetch_section(message,mime,&data,&len);
             part.setSize(len);
             part.setPositionlist(countlist);
             b = gen_attachment_id();
             part.setIdentifier(b);
             part.setType("message");
             part.setSubtype("rfc822");
             bodyCache[b]=new encodedString(data,len);
             target.addPart(part);
         }
         if (mime->mm_data.mm_message.mm_msg_mime != NULL) {
             traverseBody(target,message,mime->mm_data.mm_message.mm_msg_mime,countlist,current_rec+1);
         }
     }
     break;
     }
 }
 
 RecBody Genericwrapper::parseMail( mailmessage * msg )
 {
     int err = MAILIMF_NO_ERROR;
     mailmime_single_fields fields;
     /* is bound to msg and will be freed there */
     mailmime * mime=0;
     RecBody body;
     memset(&fields, 0, sizeof(struct mailmime_single_fields));
     err = mailmessage_get_bodystructure(msg,&mime);
     QValueList<int>recList;
     traverseBody(body,msg,mime,recList);
     return body;
 }
 
 QString Genericwrapper::parseDateTime( mailimf_date_time *date )
 {
     char tmp[23];
 
     snprintf( tmp, 23,  "%02i.%02i.%04i %02i:%02i:%02i %+05i",
         date->dt_day, date->dt_month, date->dt_year, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone );
 
     return QString( tmp );
 }
 
 QString Genericwrapper::parseAddressList( mailimf_address_list *list )
 {
     QString result( "" );
 
     bool first = true;
     if (list == 0) return result;
     for ( clistiter *current = clist_begin( list->ad_list ); current != NULL; current = current->next ) {
         mailimf_address *addr = (mailimf_address *) current->data;
 
         if ( !first ) {
             result.append( "," );
         } else {
             first = false;
         }
 
         switch ( addr->ad_type ) {
             case MAILIMF_ADDRESS_MAILBOX:
                 result.append( parseMailbox( addr->ad_data.ad_mailbox ) );
                 break;
             case MAILIMF_ADDRESS_GROUP:
                 result.append( parseGroup( addr->ad_data.ad_group ) );
                 break;
             default:
                 qDebug( "Generic: unkown mailimf address type" );
                 break;
         }
     }
 
     return result;
 }
 
 QString Genericwrapper::parseGroup( mailimf_group *group )
 {
     QString result( "" );
 
     result.append( group->grp_display_name );
     result.append( ": " );
 
     if ( group->grp_mb_list != NULL ) {
         result.append( parseMailboxList( group->grp_mb_list ) );
     }
 
     result.append( ";" );
 
     return result;
 }
 
 QString Genericwrapper::parseMailbox( mailimf_mailbox *box )
 {
     QString result( "" );
 
     if ( box->mb_display_name == NULL ) {
         result.append( box->mb_addr_spec );
     } else {
         result.append( convert_String(box->mb_display_name).latin1() );
         result.append( " <" );
         result.append( box->mb_addr_spec );
         result.append( ">" );
     }
 
     return result;
 }
 
 QString Genericwrapper::parseMailboxList( mailimf_mailbox_list *list )
 {
     QString result( "" );
 
     bool first = true;
     for ( clistiter *current = clist_begin( list->mb_list ); current != NULL; current = current->next ) {
         mailimf_mailbox *box = (mailimf_mailbox *) current->data;
 
         if ( !first ) {
             result.append( "," );
         } else {
             first = false;
         }
 
         result.append( parseMailbox( box ) );
     }
 
     return result;
 }
 
 encodedString* Genericwrapper::fetchDecodedPart(const RecMailP&,const RecPart&part)
 {
     QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part.Identifier());
     if (it==bodyCache.end()) return new encodedString();
     encodedString*t = decode_String(it.data(),part.Encoding());
     return t;
 }
 
 encodedString* Genericwrapper::fetchRawPart(const RecMailP&mail,const RecPart&part)
 {
     QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part.Identifier());
     if (it==bodyCache.end()) return new encodedString();
     encodedString*t = it.data();
     return t;
 }
 
 QString Genericwrapper::fetchTextPart(const RecMailP&mail,const RecPart&part)
 {
     encodedString*t = fetchDecodedPart(mail,part);
     QString text=t->Content();
     delete t;
     return text;
 }
 
 void Genericwrapper::cleanMimeCache()
 {
     QMap<QString,encodedString*>::Iterator it = bodyCache.begin();
     for (;it!=bodyCache.end();++it) {
         encodedString*t = it.data();
         //it.setValue(0);
         if (t) delete t;
     }
     bodyCache.clear();
     qDebug("Genericwrapper: cache cleaned");
 }
 
 QStringList Genericwrapper::parseInreplies(mailimf_in_reply_to * in_replies)
 {
     QStringList res;
     if (!in_replies || !in_replies->mid_list) return res;
     clistiter * current = 0;
     for ( current = clist_begin( in_replies->mid_list ); current != NULL; current = current->next ) {
         QString h((char*)current->data);
         while (h.length()>0 && h[0]=='<') {
             h.remove(0,1);
         }
         while (h.length()>0 && h[h.length()-1]=='>') {
             h.remove(h.length()-1,1);
         }
         if (h.length()>0) {
             res.append(h);
         }
     }
     return res;
 }
 
-void Genericwrapper::parseList(QValueList<Opie::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to)
+void Genericwrapper::parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to)
 {
     int r;
     mailmessage_list * env_list = 0;
     r = mailsession_get_messages_list(session,&env_list);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error message list");
         return;
     }
     r = mailsession_get_envelopes_list(session, env_list);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error filling message list");
         if (env_list) {
             mailmessage_list_free(env_list);
         }
         return;
     }
     mailimf_references * refs = 0;
     mailimf_in_reply_to * in_replies = 0;
     uint32_t i = 0;
     for(; i < carray_count(env_list->msg_tab) ; ++i) {
         mailmessage * msg;
         QBitArray mFlags(7);
         msg = (mailmessage*)carray_get(env_list->msg_tab, i);
         if (msg->msg_fields == NULL) {
             //qDebug("could not fetch envelope of message %i", i);
             continue;
         }
         RecMailP mail = new RecMail();
         mail->setWrapper(this);
         mail_flags * flag_result = 0;
         r = mailmessage_get_flags(msg,&flag_result);
         if (r == MAIL_ERROR_NOT_IMPLEMENTED) {
             mFlags.setBit(FLAG_SEEN);
         }
         mailimf_single_fields single_fields;
         mailimf_single_fields_init(&single_fields, msg->msg_fields);
         mail->setMsgsize(msg->msg_size);
         mail->setFlags(mFlags);
         mail->setMbox(mailbox);
         mail->setNumber(msg->msg_index);
         if (single_fields.fld_subject)
             mail->setSubject( convert_String(single_fields.fld_subject->sbj_value));
         if (single_fields.fld_from)
             mail->setFrom(parseMailboxList(single_fields.fld_from->frm_mb_list));
         if (!mbox_as_to) {
             if (single_fields.fld_to)
                 mail->setTo( parseAddressList( single_fields.fld_to->to_addr_list ) );
         } else {
             mail->setTo(mailbox);
         }
         if (single_fields.fld_cc)
             mail->setCC( parseAddressList( single_fields.fld_cc->cc_addr_list ) );
         if (single_fields.fld_bcc)
             mail->setBcc( parseAddressList( single_fields.fld_bcc->bcc_addr_list ) );
         if (single_fields.fld_orig_date)
             mail->setDate( parseDateTime( single_fields.fld_orig_date->dt_date_time ) );
         // crashes when accessing pop3 account?
         if (single_fields.fld_message_id->mid_value) {
             mail->setMsgid(QString(single_fields.fld_message_id->mid_value));
             qDebug("Msgid == %s",mail->Msgid().latin1());
         }
 
         if (single_fields.fld_reply_to) {
             QStringList t = parseAddressList(single_fields.fld_reply_to->rt_addr_list);
             if (t.count()>0) {
                 mail->setReplyto(t[0]);
             }
         }
 #if 0
         refs = single_fields.fld_references;
         if (refs && refs->mid_list && clist_count(refs->mid_list)) {
             char * text = (char*)refs->mid_list->first->data;
             mail->setReplyto(QString(text));
         }
 #endif
         if (single_fields.fld_in_reply_to && single_fields.fld_in_reply_to->mid_list &&
                 clist_count(single_fields.fld_in_reply_to->mid_list)) {
             mail->setInreply(parseInreplies(single_fields.fld_in_reply_to));
         }
         target.append(mail);
     }
     if (env_list) {
         mailmessage_list_free(env_list);
     }
 }
diff --git a/noncore/net/mail/libmailwrapper/genericwrapper.h b/noncore/net/mail/libmailwrapper/genericwrapper.h
index f9968d1..f5b9504 100644
--- a/noncore/net/mail/libmailwrapper/genericwrapper.h
+++ b/noncore/net/mail/libmailwrapper/genericwrapper.h
@@ -1,67 +1,67 @@
 #ifndef __GENERIC_WRAPPER_H
 #define __GENERIC_WRAPPER_H
 
 #include "abstractmail.h"
 #include <qmap.h>
 #include <qstring.h>
 #include <libetpan/clist.h>
 
 class RecMail;
 class RecBody;
 class encodedString;
 struct mailpop3;
 struct mailmessage;
 struct mailmime;
 struct mailmime_mechanism;
 struct mailimf_mailbox_list;
 struct mailimf_mailbox;
 struct mailimf_date_time;
 struct mailimf_group;
 struct mailimf_address_list;
 struct mailsession;
 struct mailstorage;
 struct mailfolder;
 struct mailimf_in_reply_to;
 
 /* this class hold just the funs shared between
  * mbox and pop3 (later mh, too) mail access.
  * it is not desigend to make a instance of it!
  */
 class Genericwrapper : public AbstractMail
 {
     Q_OBJECT
 public:
     Genericwrapper();
     virtual ~Genericwrapper();
 
     virtual encodedString* fetchDecodedPart(const RecMailP&mail,const RecPart&part);
     virtual encodedString* fetchRawPart(const RecMailP&mail,const RecPart&part);
     virtual QString fetchTextPart(const RecMailP&mail,const RecPart&part);
     virtual void cleanMimeCache();
-    virtual int deleteMbox(const Opie::OSmartPointer<Folder>&){return 1;}
+    virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&){return 1;}
     virtual void logout(){};
     virtual void storeMessage(const char*msg,size_t length, const QString&folder){};
 
 protected:
     RecBody parseMail( mailmessage * msg );
     QString parseMailboxList( mailimf_mailbox_list *list );
     QString parseMailbox( mailimf_mailbox *box );
     QString parseGroup( mailimf_group *group );
     QString parseAddressList( mailimf_address_list *list );
     QString parseDateTime( mailimf_date_time *date );
 
     void traverseBody(RecBody&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rek=0,int current_count=1);
     static void fillSingleBody(RecPart&target,mailmessage*message,mailmime*mime);
     static void fillParameters(RecPart&target,clist*parameters);
     static QString getencoding(mailmime_mechanism*aEnc);
-    virtual void parseList(QValueList<Opie::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to=false);
+    virtual void parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to=false);
     QStringList parseInreplies(mailimf_in_reply_to * in_replies);
 
     QString msgTempName;
     unsigned int last_msg_id;
     QMap<QString,encodedString*> bodyCache;
     mailstorage * m_storage;
     mailfolder*m_folder;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.cpp b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
index 071e734..56e7df9 100644
--- a/noncore/net/mail/libmailwrapper/imapwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
@@ -1,461 +1,462 @@
 #include <stdlib.h>
 #include <libetpan/libetpan.h>
 #include <qpe/global.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 ) {
         qDebug("error selecting mailbox: %s",m_imap->imap_response);
         m_Lastmbox = "";
         return err;
     }
     m_Lastmbox = mbox;
     return err;
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     qDebug( "IMAP: %i of %i", current, maximum );
 }
 
 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!");
         qDebug("error getting capabilities!");
         return false;
     }
     clistiter * cur;
     for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) {
         struct mailimap_capability * cap;
         cap  = (struct mailimap_capability *)clist_content(cur);
         if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) {
             if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) {
                 try_tls = true;
                 break;
             }
         }
     }
     if (cap_data) {
         mailimap_capability_data_free(cap_data);
     }
     if (try_tls) {
         err =  mailimap_starttls(m_imap);
         if (err != MAILIMAP_NO_ERROR && force_tls) {
             Global::statusMessage(tr("Server has no TLS support!"));
             qDebug("Server has no TLS support!");
             try_tls = false;
         } else {
             mailstream_low * low;
             mailstream_low * new_low;
             low = mailstream_get_low(m_imap->imap_stream);
             if (!low) {
                 try_tls = false;
             } else {
                 int fd = mailstream_low_get_fd(low);
                 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
                     mailstream_low_free(low);
                     mailstream_set_low(m_imap->imap_stream, new_low);
                 } else {
                     try_tls = false;
                 }
             }
         }
    }
    return try_tls;
 }
 
 void IMAPwrapper::login()
 {
     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 */
     bool ssl = false;
     bool try_tls = false;
     bool force_tls = false;
 
     if  ( account->ConnectionType() == 2 ) {
         ssl = true;
     }
     if (account->ConnectionType()==1) {
         force_tls = true;
     }
 
     if ( ssl ) {
         qDebug(  "using ssl" );
         err = mailimap_ssl_connect( m_imap, (char*)server, 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;
     }
 
     if (!ssl) {
         try_tls = start_tls(force_tls);
     }
 
     bool ok = true;
     if (force_tls && !try_tls) {
         Global::statusMessage(tr("Server has no TLS support!"));
         qDebug("Server has no TLS support!");
         ok = false;
     }
 
 
     /* login */
 
     if (ok) {
         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));
             ok = false;
         }
     }
     if (!ok) {
         err = mailimap_close( m_imap );
         mailimap_free( m_imap );
         m_imap = 0;
     }
 }
 
 void IMAPwrapper::logout()
 {
     int err = MAILIMAP_NO_ERROR;
     if (!m_imap) return;
     err = mailimap_logout( m_imap );
     err = mailimap_close( m_imap );
     mailimap_free( m_imap );
     m_imap = 0;
     m_Lastmbox = "";
 }
 
-void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::OSmartPointer<RecMail> > &target )
+void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> > &target )
 {
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current;
     mailimap_fetch_type *fetchType = 0;
     mailimap_set *set = 0;
 
     login();
     if (!m_imap) {
         return;
     }
     /* select mailbox READONLY for operations */
     err = selectMbox(mailbox);
     if ( err != MAILIMAP_NO_ERROR ) {
         return;
     }
 
     int last = m_imap->imap_selection_info->sel_exists;
 
     if (last == 0) {
         Global::statusMessage(tr("Mailbox has no mails"));
         return;
     } else {
     }
 
     /* 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);
             }
         }
         Global::statusMessage(tr("Mailbox has %1 mails").arg(target.count()));
     } else {
         Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response));
     }
     if (result) mailimap_fetch_list_free(result);
 }
 
-QValueList<Opie::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
+QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
 {
     const char *path, *mask;
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current = 0;
     clistcell*cur_flag = 0;
     mailimap_mbx_list_flags*bflags = 0;
 
     QValueList<FolderP>* folders = new QValueList<FolderP>();
     login();
     if (!m_imap) {
         return folders;
     }
 
 /*
  * First we have to check for INBOX 'cause it sometimes it's not inside the path.
  * We must not forget to filter them out in next loop!
  * it seems like ugly code. and yes - it is ugly code. but the best way.
  */
     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 );
 
 /*
  * second stage - get the other then inbox folders
  */
     mask = "*" ;
     path = account->getPrefix().latin1();
     if (!path) path = "";
     qDebug(path);
     err = mailimap_list( m_imap, (char*)path, (char*)mask, &result );
     if ( err == MAILIMAP_NO_ERROR ) {
         current = result->first;
         for ( current=clist_begin(result);current!=NULL;current=clist_next(current)) {
             no_inferiors = false;
             list = (mailimap_mailbox_list *) current->data;
             // it is better use the deep copy mechanism of qt itself
             // instead of using strdup!
             temp = list->mb_name;
             if (temp.lower()=="inbox")
                 continue;
             if (temp.lower()==account->getPrefix().lower())
                 continue;
             if ( (bflags = list->mb_flag) ) {
                 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&&
                             bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT);
                 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) {
                     if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) {
                         no_inferiors = true;
                     }
                 }
             }
             del = list->mb_delimiter;
             folders->append(new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix()));
         }
     } else {
         qDebug("error fetching folders %s",m_imap->imap_response);
     }
     if (result) mailimap_list_result_free( result );
     return folders;
 }
 
 RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att)
 {
     RecMail * m = 0;
     mailimap_msg_att_item *item=0;
     clistcell *current,*c,*cf;
     mailimap_msg_att_dynamic*flist;
     mailimap_flag_fetch*cflag;
     int size;
     QBitArray mFlags(7);
     QStringList addresslist;
 
     if (!m_att) {
         return m;
     }
     m = new RecMail();
     for (c = clist_begin(m_att->att_list); c!=NULL;c=clist_next(c) ) {
         current = c;
         size = 0;
         item = (mailimap_msg_att_item*)current->data;
         if (item->att_type!=MAILIMAP_MSG_ATT_ITEM_STATIC) {
             flist = (mailimap_msg_att_dynamic*)item->att_data.att_dyn;
             if (!flist->att_list) {
                 continue;
             }
             cf = flist->att_list->first;
             for (cf = clist_begin(flist->att_list); cf!=NULL; cf = clist_next(cf)) {
                 cflag = (mailimap_flag_fetch*)cf->data;
                 if (cflag->fl_type==MAILIMAP_FLAG_FETCH_OTHER && cflag->fl_flag!=0) {
                     switch (cflag->fl_flag->fl_type) {
                     case MAILIMAP_FLAG_ANSWERED:  /* \Answered flag */
                         mFlags.setBit(FLAG_ANSWERED);
                         break;
                     case MAILIMAP_FLAG_FLAGGED:   /* \Flagged flag */
                         mFlags.setBit(FLAG_FLAGGED);
                         break;
                     case MAILIMAP_FLAG_DELETED:   /* \Deleted flag */
                         mFlags.setBit(FLAG_DELETED);
                         break;
                     case MAILIMAP_FLAG_SEEN:      /* \Seen flag */
                         mFlags.setBit(FLAG_SEEN);
                         break;
                     case MAILIMAP_FLAG_DRAFT:     /* \Draft flag */
                         mFlags.setBit(FLAG_DRAFT);
                         break;
                     case MAILIMAP_FLAG_KEYWORD:   /* keyword flag */
                         break;
                     case MAILIMAP_FLAG_EXTENSION: /* \extension flag */
                         break;
                     default:
                         break;
                     }
                 } else if (cflag->fl_type==MAILIMAP_FLAG_FETCH_RECENT) {
                     mFlags.setBit(FLAG_RECENT);
                 }
             }
             continue;
         }
         if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_ENVELOPE) {
             mailimap_envelope * head = item->att_data.att_static->att_data.att_env;
             m->setDate(head->env_date);
             m->setSubject(convert_String((const char*)head->env_subject));
             //m->setSubject(head->env_subject);
             if (head->env_from!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_from->frm_list);
                 if (addresslist.count()) {
                     m->setFrom(addresslist.first());
                 }
             }
             if (head->env_to!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_to->to_list);
                 m->setTo(addresslist);
             }
             if (head->env_cc!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_cc->cc_list);
                 m->setCC(addresslist);
             }
             if (head->env_bcc!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_bcc->bcc_list);
                 m->setBcc(addresslist);
             }
             /* reply to address, eg. email. */
             if (head->env_reply_to!=NULL) {
                 addresslist = address_list_to_stringlist(head->env_reply_to->rt_list);
                 if (addresslist.count()) {
                     m->setReplyto(addresslist.first());
                 }
             }
             if (head->env_in_reply_to!=NULL) {
                 QString h(head->env_in_reply_to);
                 while (h.length()>0 && h[0]=='<') {
                     h.remove(0,1);
                 }
                 while (h.length()>0 && h[h.length()-1]=='>') {
                     h.remove(h.length()-1,1);
                 }
                 if (h.length()>0) {
                     m->setInreply(QStringList(h));
                 }
             }
             if (head->env_message_id) {
                 m->setMsgid(QString(head->env_message_id));
             }
diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.h b/noncore/net/mail/libmailwrapper/imapwrapper.h
index 3bd5967..7448acb 100644
--- a/noncore/net/mail/libmailwrapper/imapwrapper.h
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.h
@@ -1,80 +1,80 @@
 #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 QValueList<Opie::OSmartPointer<Folder> >* listFolders();
-    virtual void listMessages(const QString & mailbox,QValueList<Opie::OSmartPointer<RecMail> >&target );
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
+    virtual void listMessages(const QString & mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> >&target );
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&folder);
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&folder);
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
-    virtual void mvcpAllMails(const Opie::OSmartPointer<Folder>&fromFolder,
+    virtual void mvcpAllMails(const Opie::Core::OSmartPointer<Folder>&fromFolder,
         const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
     virtual void mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
 
     virtual RecBody fetchBody(const RecMailP&mail);
     virtual QString fetchTextPart(const RecMailP&mail,const RecPart&part);
     virtual encodedString* fetchDecodedPart(const RecMailP&mail,const RecPart&part);
     virtual encodedString* fetchRawPart(const RecMailP&mail,const RecPart&part);
     virtual encodedString* fetchRawBody(const RecMailP&mail);
 
-    virtual int createMbox(const QString&,const Opie::OSmartPointer<Folder>&parentfolder=0,
+    virtual int createMbox(const QString&,const Opie::Core::OSmartPointer<Folder>&parentfolder=0,
         const QString& delemiter="/",bool getsubfolder=false);
-    virtual int deleteMbox(const Opie::OSmartPointer<Folder>&folder);
+    virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&folder);
 
     static void imap_progress( size_t current, size_t maximum );
 
     virtual void logout();
     virtual MAILLIB::ATYPE getType()const;
     virtual const QString&getName()const;
 
 protected:
     RecMail*parse_list_result(mailimap_msg_att*);
     void login();
     bool start_tls(bool force=true);
 
     virtual QString fetchTextPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call=false,const QString&enc="");
     virtual encodedString*fetchRawPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call);
     int selectMbox(const QString&mbox);
 
     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 RecMailP&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;
     QString m_Lastmbox;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/mailtypes.cpp b/noncore/net/mail/libmailwrapper/mailtypes.cpp
index 7dd7e58..fd91fe5 100644
--- a/noncore/net/mail/libmailwrapper/mailtypes.cpp
+++ b/noncore/net/mail/libmailwrapper/mailtypes.cpp
@@ -1,203 +1,204 @@
 #include "mailtypes.h"
 #include <stdlib.h>
 
+using namespace Opie::Core;
 RecMail::RecMail()
-    :Opie::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_size(0),msg_flags(7)
+    :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::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_flags(7)
+    :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_flags(7)
 {
     init();
     copy_old(old);
     qDebug("Copy constructor RecMail");
 }
 
 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;
 }
 
 const QStringList& RecMail::Inreply()const
 {
     return in_reply_to;
 }
 
 void RecMail::setReferences(const QStringList&list)
 {
     references = list;
 }
 
 const QStringList& RecMail::References()const
 {
     return references;
 }
 
 RecPart::RecPart()
     : m_type(""),m_subtype(""),m_identifier(""),m_encoding(""),m_description(""),m_lines(0),m_size(0)
 {
     m_Parameters.clear();
     m_poslist.clear();
 }
 
 RecPart::~RecPart()
 {
 }
 
 void RecPart::setSize(unsigned int size)
 {
     m_size = size;
 }
 
 const unsigned int RecPart::Size()const
 {
     return m_size;
 }
 
 void RecPart::setLines(unsigned int lines)
 {
     m_lines = lines;
 }
 
 const unsigned int RecPart::Lines()const
 {
     return m_lines;
 }
 
 const QString& RecPart::Type()const
 {
     return m_type;
 }
 
 void RecPart::setType(const QString&type)
 {
     m_type = type;
 }
 
 const QString& RecPart::Subtype()const
 {
     return m_subtype;
 }
 
 void RecPart::setSubtype(const QString&subtype)
 {
     m_subtype = subtype;
 }
 
 const QString& RecPart::Identifier()const
 {
     return m_identifier;
 }
 
 void RecPart::setIdentifier(const QString&identifier)
 {
     m_identifier = identifier;
 }
 
 const QString& RecPart::Encoding()const
 {
     return m_encoding;
 }
 
 void RecPart::setEncoding(const QString&encoding)
 {
     m_encoding = encoding;
 }
 
 const QString& RecPart::Description()const
 {
     return m_description;
 }
 
 void RecPart::setDescription(const QString&desc)
 {
     m_description = desc;
 }
 
 void RecPart::setParameters(const part_plist_t&list)
 {
     m_Parameters = list;
 }
 
 const part_plist_t& RecPart::Parameters()const
 {
     return m_Parameters;
 }
 
 void RecPart::addParameter(const QString&key,const QString&value)
diff --git a/noncore/net/mail/libmailwrapper/mailtypes.h b/noncore/net/mail/libmailwrapper/mailtypes.h
index dc10de6..941556a 100644
--- a/noncore/net/mail/libmailwrapper/mailtypes.h
+++ b/noncore/net/mail/libmailwrapper/mailtypes.h
@@ -1,200 +1,200 @@
 #ifndef __MAIL_TYPES_H
 #define __MAIL_TYPES_H
 
 #define FLAG_ANSWERED 0
 #define FLAG_FLAGGED  1
 #define FLAG_DELETED  2
 #define FLAG_SEEN     3
 #define FLAG_DRAFT    4
 #define FLAG_RECENT   5
 
 #include <opie2/osmartpointer.h>
 
 #include <qbitarray.h>
 #include <qstring.h>
 #include <qstringlist.h>
 #include <qmap.h>
 #include <qvaluelist.h>
 
 class AbstractMail;
 /* a class to describe mails in a mailbox */
 /* Attention!
    From programmers point of view it would make sense to
    store the mail body into this class, too.
    But: not from the point of view of the device.
    Mailbodies can be real large. So we request them when
    needed from the mail-wrapper class direct from the server itself
    (imap) or from a file-based cache (pop3?)
    So there is no interface "const QString&body()" but you should
    make a request to the mailwrapper with this class as parameter to
    get the body. Same words for the attachments.
 */
-class RecMail:public Opie::ORefCount
+class RecMail:public Opie::Core::ORefCount
 {
 public:
     RecMail();
     RecMail(const RecMail&old);
     virtual ~RecMail();
 
     const unsigned int getNumber()const{return msg_number;}
     void setNumber(unsigned int number){msg_number=number;}
     const QString&getDate()const{ return date; }
     void setDate( const QString&a ) { date = a; }
     const QString&getFrom()const{ return from; }
     void setFrom( const QString&a ) { from = a; }
     const QString&getSubject()const { return subject; }
     void setSubject( const QString&s ) { subject = s; }
     const QString&getMbox()const{return mbox;}
     void setMbox(const QString&box){mbox = box;}
     void setMsgid(const QString&id){msg_id=id;}
     const QString&Msgid()const{return msg_id;}
     void setReplyto(const QString&reply){replyto=reply;}
     const QString&Replyto()const{return replyto;}
     void setMsgsize(unsigned int size){msg_size = size;}
     const unsigned int Msgsize()const{return msg_size;}
 
 
     void setTo(const QStringList&list);
     const QStringList&To()const;
     void setCC(const QStringList&list);
     const QStringList&CC()const;
     void setBcc(const QStringList&list);
     const QStringList&Bcc()const;
     void setInreply(const QStringList&list);
     const QStringList&Inreply()const;
     void setReferences(const QStringList&list);
     const QStringList&References()const;
 
     const QBitArray&getFlags()const{return msg_flags;}
     void setFlags(const QBitArray&flags){msg_flags = flags;}
 
     void setWrapper(AbstractMail*wrapper);
     AbstractMail* Wrapper();
 
 protected:
     QString subject,date,from,mbox,msg_id,replyto;
     unsigned int msg_number,msg_size;
     QBitArray msg_flags;
     QStringList to,cc,bcc,in_reply_to,references;
     AbstractMail*wrapper;
     void init();
     void copy_old(const RecMail&old);
 };
 
-typedef Opie::OSmartPointer<RecMail> RecMailP;
+typedef Opie::Core::OSmartPointer<RecMail> RecMailP;
 typedef QMap<QString,QString> part_plist_t;
 
 class RecPart
 {
 protected:
     QString m_type,m_subtype,m_identifier,m_encoding,m_description;
     unsigned int m_lines,m_size;
     part_plist_t m_Parameters;
     /* describes the position in the mail */
     QValueList<int> m_poslist;
 
 public:
     RecPart();
     virtual ~RecPart();
 
     const QString&Type()const;
     void setType(const QString&type);
     const QString&Subtype()const;
     void setSubtype(const QString&subtype);
     const QString&Identifier()const;
     void setIdentifier(const QString&identifier);
     const QString&Encoding()const;
     void setEncoding(const QString&encoding);
     const QString&Description()const;
     void setDescription(const QString&desc);
     void setLines(unsigned int lines);
     const unsigned int Lines()const;
     void setSize(unsigned int size);
     const unsigned int Size()const;
 
 
     void setParameters(const part_plist_t&list);
     const part_plist_t&Parameters()const;
     void addParameter(const QString&key,const QString&value);
     const QString searchParamter(const QString&key)const;
     void setPositionlist(const QValueList<int>&poslist);
     const QValueList<int>& Positionlist()const;
 };
 
 class RecBody
 {
 protected:
     QString m_BodyText;
     QValueList<RecPart> m_PartsList;
     RecPart m_description;
 
 public:
     RecBody();
     virtual ~RecBody();
     void setBodytext(const QString&);
     const QString& Bodytext()const;
 
     void setDescription(const RecPart&des);
     const RecPart& Description()const;
 
     void setParts(const QValueList<RecPart>&parts);
     const QValueList<RecPart>& Parts()const;
     void addPart(const RecPart&part);
 };
 
 class encodedString
 {
 public:
     encodedString();
     /*
        creates an new content string.
        it makes a deep copy of it!
      */
     encodedString(const char*nContent,unsigned int length);
     /*
       Take over the nContent. Means: it will just copy the pointer, not the content.
        so make sure: No one else frees the string, the string has allocated with
        malloc for compatibility with c-based libs
     */
     encodedString(char*nContent,unsigned int nSize);
     /* copy construkor - makes ALWAYS a deep copy!!!! */
     encodedString(const encodedString&old);
     /* assign operator - makes ALWAYS a deep copy!!!! */
     encodedString& operator=(const encodedString&old);
     /* destructor - cleans the content */
     virtual ~encodedString();
 
     /* returns a pointer to the content - do not delete yoursel! */
     const char*Content()const;
     /* returns the lengths of the content 'cause it must not be a null-terminated string! */
     const int Length()const;
 
     /*
        makes a deep copy of nContent!
      */
     void setContent(const char*nContent,int nSize);
     /*
       Take over the nContent. Means: it will just copy the pointer, not the content.
        so make sure: No one else frees the string, the string has allocated with
        malloc for compatibility with c-based libs
     */
     void setContent(char*nContent,int nSize);
 
 protected:
     char * content;
     unsigned int size;
 
     void init();
     void copy_old(const encodedString&old);
     void clean();
 };
 
 struct folderStat
 {
     unsigned int message_count;
     unsigned int message_unseen;
     unsigned int message_recent;
     folderStat&operator=(const folderStat&old);
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/mailwrapper.cpp b/noncore/net/mail/libmailwrapper/mailwrapper.cpp
index 9bf2fd3..eddc0b9 100644
--- a/noncore/net/mail/libmailwrapper/mailwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mailwrapper.cpp
@@ -1,178 +1,179 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
 #include <qdir.h>
 
 #include "mailwrapper.h"
 //#include "logindialog.h"
 //#include "defines.h"
 
 #define UNDEFINED 64
 #define MAXLINE  76
 #define UTF16MASK       0x03FFUL
 #define UTF16SHIFT      10
 #define UTF16BASE       0x10000UL
 #define UTF16HIGHSTART  0xD800UL
 #define UTF16HIGHEND    0xDBFFUL
 #define UTF16LOSTART    0xDC00UL
 #define UTF16LOEND      0xDFFFUL
 
 
+using namespace Opie::Core;
 Attachment::Attachment( DocLnk lnk )
 {
     doc = lnk;
     size = QFileInfo( doc.file() ).size();
 }
 
 Folder::Folder(const QString&tmp_name, const QString&sep  )
 {
     name = tmp_name;
     nameDisplay = name;
     separator = sep;
     prefix = "";
 }
 
 Folder::~Folder()
 {
 }
 
 const QString& Folder::Separator()const
 {
     return separator;
 }
 
 IMAPFolder::IMAPFolder(const QString&name,const QString&sep, bool select,bool no_inf, const QString&aprefix )
     : Folder( name,sep ),m_MaySelect(select),m_NoInferior(no_inf)
 {
   // Decode IMAP foldername
   nameDisplay = IMAPFolder::decodeFolderName( name );
   /*
   qDebug( "folder " + name + " - displayed as " + nameDisplay );
   */
     prefix = aprefix;
 
     if (prefix.length()>0) {
         if (nameDisplay.startsWith(prefix) && nameDisplay.length()>prefix.length()) {
             nameDisplay=nameDisplay.right(nameDisplay.length()-prefix.length());
         }
     }
 }
 
 IMAPFolder::~IMAPFolder()
 {
 }
 
 static unsigned char base64chars[] =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
 
 /**
  * Decodes base64 encoded parts of the imapfolder name
  * Code taken from kde cvs: kdebase/kioslave/imap4/rfcdecoder.cc
  */
 QString IMAPFolder::decodeFolderName( const QString &name )
 {
   unsigned char c, i, bitcount;
   unsigned long ucs4, utf16, bitbuf;
   unsigned char base64[256], utf8[6];
   unsigned long srcPtr = 0;
   QCString dst = "";
   QCString src = name.ascii();
 
   /* initialize modified base64 decoding table */
   memset(base64, UNDEFINED, sizeof(base64));
   for (i = 0; i < sizeof(base64chars); ++i) {
     base64[(int)base64chars[i]] = i;
   }
 
   /* loop until end of string */
   while (srcPtr < src.length ()) {
     c = src[srcPtr++];
     /* deal with literal characters and &- */
     if (c != '&' || src[srcPtr] == '-') {
       /* encode literally */
       dst += c;
       /* skip over the '-' if this is an &- sequence */
       if (c == '&')
         srcPtr++;
     } else {
       /* convert modified UTF-7 -> UTF-16 -> UCS-4 -> UTF-8 -> HEX */
       bitbuf = 0;
       bitcount = 0;
       ucs4 = 0;
       while ((c = base64[(unsigned char) src[srcPtr]]) != UNDEFINED) {
         ++srcPtr;
         bitbuf = (bitbuf << 6) | c;
         bitcount += 6;
         /* enough bits for a UTF-16 character? */
         if (bitcount >= 16) {
           bitcount -= 16;
           utf16 = (bitcount ? bitbuf >> bitcount : bitbuf) & 0xffff;
           /* convert UTF16 to UCS4 */
           if (utf16 >= UTF16HIGHSTART && utf16 <= UTF16HIGHEND) {
             ucs4 = (utf16 - UTF16HIGHSTART) << UTF16SHIFT;
             continue;
           } else if (utf16 >= UTF16LOSTART && utf16 <= UTF16LOEND) {
             ucs4 += utf16 - UTF16LOSTART + UTF16BASE;
           } else {
             ucs4 = utf16;
           }
           /* convert UTF-16 range of UCS4 to UTF-8 */
           if (ucs4 <= 0x7fUL) {
             utf8[0] = ucs4;
             i = 1;
           } else if (ucs4 <= 0x7ffUL) {
             utf8[0] = 0xc0 | (ucs4 >> 6);
             utf8[1] = 0x80 | (ucs4 & 0x3f);
             i = 2;
           } else if (ucs4 <= 0xffffUL) {
             utf8[0] = 0xe0 | (ucs4 >> 12);
             utf8[1] = 0x80 | ((ucs4 >> 6) & 0x3f);
             utf8[2] = 0x80 | (ucs4 & 0x3f);
             i = 3;
           } else {
             utf8[0] = 0xf0 | (ucs4 >> 18);
             utf8[1] = 0x80 | ((ucs4 >> 12) & 0x3f);
             utf8[2] = 0x80 | ((ucs4 >> 6) & 0x3f);
             utf8[3] = 0x80 | (ucs4 & 0x3f);
             i = 4;
           }
           /* copy it */
           for (c = 0; c < i; ++c) {
             dst += utf8[c];
           }
         }
       }
       /* skip over trailing '-' in modified UTF-7 encoding */
       if (src[srcPtr] == '-')
         ++srcPtr;
     }
   }
 
   return QString::fromUtf8( dst.data() );
 }
 
 Mail::Mail()
-    :Opie::ORefCount(),name(""), mail(""), to(""), cc(""), bcc(""), reply(""), subject(""), message("")
+    :Opie::Core::ORefCount(),name(""), mail(""), to(""), cc(""), bcc(""), reply(""), subject(""), message("")
 {
 }
 
 MHFolder::MHFolder(const QString&disp_name,const QString&mbox)
     : Folder( disp_name,"/" )
 {
     separator = "/";
     name = mbox;
     if (!disp_name.startsWith("/") && disp_name.length()>0)
         name+="/";
     name+=disp_name;
     if (disp_name.length()==0) {
         nameDisplay = separator;
     }
     prefix = mbox;
 }
 
 MHFolder::~MHFolder()
 {
 }
diff --git a/noncore/net/mail/libmailwrapper/mailwrapper.h b/noncore/net/mail/libmailwrapper/mailwrapper.h
index 6bf0078..542de03 100644
--- a/noncore/net/mail/libmailwrapper/mailwrapper.h
+++ b/noncore/net/mail/libmailwrapper/mailwrapper.h
@@ -1,106 +1,106 @@
 #ifndef MAILWRAPPER_H
 #define MAILWRAPPER_H
 
 #include <qpe/applnk.h>
 
 #include <qbitarray.h>
 #include <qdatetime.h>
 
 #include "settings.h"
 
 #include <opie2/osmartpointer.h>
 
 class Attachment
 {
 public:
     Attachment( DocLnk lnk );
     virtual ~Attachment(){}
     const QString getFileName()const{ return doc.file(); }
     const QString getName()const{ return doc.name(); }
     const QString getMimeType()const{ return doc.type(); }
     const QPixmap getPixmap()const{ return doc.pixmap(); }
     const int getSize()const { return size; }
     DocLnk  getDocLnk() { return doc; }
 
 protected:
     DocLnk doc;
     int size;
 
 };
 
-class Mail:public Opie::ORefCount
+class Mail:public Opie::Core::ORefCount
 {
 public:
     Mail();
     /* Possible that this destructor must not be declared virtual
      * 'cause it seems that it will never have some child classes.
      * in this case this object will not get a virtual table -> memory and
      * speed will be a little bit better?
      */
     virtual ~Mail(){}
     void addAttachment( Attachment *att ) { attList.append( att ); }
     const QList<Attachment>& getAttachments()const { return attList; }
     void removeAttachment( Attachment *att ) { attList.remove( att ); }
     const QString&getName()const { return name; }
     void setName( QString s ) { name = s; }
     const QString&getMail()const{ return mail; }
     void setMail( const QString&s ) { mail = s; }
     const QString&getTo()const{ return to; }
     void setTo( const QString&s ) { to = s; }
     const QString&getCC()const{ return cc; }
     void setCC( const QString&s ) { cc = s; }
     const QString&getBCC()const { return bcc; }
     void setBCC( const QString&s ) { bcc = s; }
     const QString&getMessage()const { return message; }
     void setMessage( const QString&s ) { message = s; }
     const QString&getSubject()const { return subject; }
     void setSubject( const QString&s ) { subject = s; }
     const QString&getReply()const{ return reply; }
     void setReply( const QString&a ) { reply = a; }
     void setInreply(const QStringList&list){m_in_reply_to = list;}
     const QStringList&Inreply()const{return m_in_reply_to;}
 
 private:
     QList<Attachment> attList;
     QString name, mail, to, cc, bcc, reply, subject, message;
     QStringList m_in_reply_to;
 };
 
-class Folder:public Opie::ORefCount
+class Folder:public Opie::Core::ORefCount
 {
 public:
     Folder( const QString&init_name,const QString&sep );
     virtual ~Folder();
     const QString&getDisplayName()const { return nameDisplay; }
     const QString&getName()const { return name; }
     const QString&getPrefix()const{return prefix; }
     virtual bool may_select()const{return true;}
     virtual bool no_inferior()const{return true;}
     const QString&Separator()const;
 
 protected:
     QString nameDisplay, name, separator,prefix;
 };
 
-typedef Opie::OSmartPointer<Folder> FolderP;
+typedef Opie::Core::OSmartPointer<Folder> FolderP;
 
 class MHFolder : public Folder
 {
 public:
     MHFolder(const QString&disp_name,const QString&mbox);
     virtual ~MHFolder();
 };
 
 class IMAPFolder : public Folder
 {
     public:
         IMAPFolder(const QString&name, const QString&sep, bool select=true,bool noinf=false,const QString&prefix="" );
         virtual ~IMAPFolder();
         virtual bool may_select()const{return m_MaySelect;}
         virtual bool no_inferior()const{return m_NoInferior;}
     private:
         static QString decodeFolderName( const QString &name );
         bool m_MaySelect,m_NoInferior;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
index 5e6b714..4aee0be 100644
--- a/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mboxwrapper.cpp
@@ -1,241 +1,242 @@
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <stdlib.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) {
         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()));
 }
 
-QValueList<Opie::OSmartPointer<Folder> >* MBOXwrapper::listFolders()
+QValueList<Opie::Core::OSmartPointer<Folder> >* MBOXwrapper::listFolders()
 {
-    QValueList<Opie::OSmartPointer<Folder> >* folders = new QValueList<Opie::OSmartPointer<Folder> >();
+    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) {
         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 RecMailP&)
 {
 }
 
 RecBody MBOXwrapper::fetchBody( const RecMailP &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 FolderP&,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 RecMailP&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,const QValueList<RecMailP> &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,const QValueList<RecMailP> &target)
 {
     if (!f) return;
     int r;
     QValueList<RecMailP>::ConstIterator it;
     for (it=target.begin(); it != target.end();++it) {
         r = mailmbox_delete_msg(f,(*it)->getNumber());
         if (r!=MAILMBOX_NO_ERROR) {
             qDebug("error delete mail");
         }
     }
     r = mailmbox_expunge(f);
     if (r != MAILMBOX_NO_ERROR) {
diff --git a/noncore/net/mail/libmailwrapper/mboxwrapper.h b/noncore/net/mail/libmailwrapper/mboxwrapper.h
index 33eeb1e..a2ecfee 100644
--- a/noncore/net/mail/libmailwrapper/mboxwrapper.h
+++ b/noncore/net/mail/libmailwrapper/mboxwrapper.h
@@ -1,46 +1,46 @@
 #ifndef __MBOX_WRAPPER_H
 #define __MBOX_WRAPPER_H
 
 #include "genericwrapper.h"
 #include <qstring.h>
 
 class encodedString;
 struct mailmbox_folder;
 
 class MBOXwrapper : public Genericwrapper
 {
     Q_OBJECT
 
 public:
     MBOXwrapper(const QString & dir,const QString&name);
     virtual ~MBOXwrapper();
 
     virtual void listMessages(const QString & mailbox, QValueList<RecMailP>&target );
-    virtual QValueList<Opie::OSmartPointer<Folder> >* listFolders();
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
 
-    virtual int createMbox(const QString&folder,const Opie::OSmartPointer<Folder>&f=0,
+    virtual int createMbox(const QString&folder,const Opie::Core::OSmartPointer<Folder>&f=0,
         const QString&d="",bool s=false);
-    virtual int deleteMbox(const Opie::OSmartPointer<Folder>&);
+    virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&);
 
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
 
     virtual RecBody fetchBody( const RecMailP &mail );
     static void mbox_progress( size_t current, size_t maximum );
 
     virtual encodedString* fetchRawBody(const RecMailP&mail);
     virtual void deleteMails(const QString & FolderName,const QValueList<RecMailP> &target);
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&);
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&);
     virtual MAILLIB::ATYPE getType()const;
     virtual const QString&getName()const;
 
 protected:
     static void deleteMails(mailmbox_folder*f,const QValueList<RecMailP> &target);
     QString MBOXPath;
     QString MBOXName;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/mhwrapper.cpp b/noncore/net/mail/libmailwrapper/mhwrapper.cpp
index 0b00a2e..21e24a0 100644
--- a/noncore/net/mail/libmailwrapper/mhwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/mhwrapper.cpp
@@ -1,441 +1,444 @@
 #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>
 
+using namespace Opie::Core;
+using namespace Opie::Core;
+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);
         }
         qDebug(MHPath);
         QDir dir(MHPath);
         if (!dir.exists()) {
             dir.mkdir(MHPath);
         }
         init_storage();
     }
 }
 
 void MHwrapper::init_storage()
 {
     int r;
     QString pre = MHPath;
     if (!m_storage) {
         m_storage = mailstorage_new(NULL);
         r = mh_mailstorage_init(m_storage,(char*)pre.latin1(),0,0,0);
         if (r != MAIL_NO_ERROR) {
             qDebug("error initializing storage");
             mailstorage_free(m_storage);
             m_storage = 0;
             return;
         }
     }
     r = mailstorage_connect(m_storage);
     if (r!=MAIL_NO_ERROR) {
         qDebug("error connecting storage");
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 void MHwrapper::clean_storage()
 {
     if (m_storage) {
         mailstorage_disconnect(m_storage);
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 MHwrapper::~MHwrapper()
 {
     clean_storage();
 }
 
-void MHwrapper::listMessages(const QString & mailbox, QValueList<Opie::OSmartPointer<RecMail> > &target )
+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) {
         qDebug("listMessages: error selecting folder!");
         return;
     }
     parseList(target,m_storage->sto_session,f);
     Global::statusMessage(tr("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
-QValueList<Opie::OSmartPointer<Folder> >* MHwrapper::listFolders()
+QValueList<Opie::Core::OSmartPointer<Folder> >* MHwrapper::listFolders()
 {
-    QValueList<Opie::OSmartPointer<Folder> >* folders = new QValueList<Opie::OSmartPointer<Folder> >();
+    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) {
         qDebug("error getting folder list");
         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)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder!");
         return;
     }
     r = mailsession_remove_message(m_storage->sto_session,mail->getNumber());
     if (r != MAIL_NO_ERROR) {
         qDebug("error deleting mail");
     }
 }
 
 void MHwrapper::answeredMail(const RecMailP&)
 {
 }
 
 RecBody MHwrapper::fetchBody( const RecMailP &mail )
 {
     RecBody body;
     init_storage();
     if (!m_storage) {
         return body;
     }
     mailmessage * msg;
     char*data=0;
 
     /* mail should hold the complete path! */
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r != MAIL_NO_ERROR) {
         return body;
     }
     r = mailsession_get_message(m_storage->sto_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error fetching mail %i",mail->getNumber());
         return body;
     }
     body = parseMail(msg);
     mailmessage_fetch_result_free(msg,data);
     return body;
 }
 
 void MHwrapper::mbox_progress( size_t current, size_t maximum )
 {
     qDebug("MH %i von %i",current,maximum);
 }
 
 QString MHwrapper::buildPath(const QString&p)
 {
     QString f="";
     if (p.length()==0||p=="/")
         return MHPath;
     if (!p.startsWith(MHPath)) {
         f+=MHPath;
     }
     if (!p.startsWith("/")) {
         f+="/";
     }
     f+=p;
     return f;
 }
 
 int MHwrapper::createMbox(const QString&folder,const FolderP&pfolder,const QString&,bool )
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     QString f;
     if (!pfolder) {
         // toplevel folder
         f  = buildPath(folder);
     } else {
         f = pfolder->getName();
         f+="/";
         f+=folder;
     }
     qDebug(f);
     int r = mailsession_create_folder(m_storage->sto_session,(char*)f.latin1());
     if (r != MAIL_NO_ERROR) {
         qDebug("error creating folder %i",r);
         return 0;
     }
     qDebug("Folder created");
     return 1;
 }
 
 void MHwrapper::storeMessage(const char*msg,size_t length, const QString&Folder)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     QString f = buildPath(Folder);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder!");
         return;
     }
     r = mailsession_append_message(m_storage->sto_session,(char*)msg,length);
     if (r!=MAIL_NO_ERROR) {
         qDebug("error storing mail");
     }
     return;
 }
 
 encodedString* MHwrapper::fetchRawBody(const RecMailP&mail)
 {
     encodedString*result = 0;
     init_storage();
     if (!m_storage) {
         return result;
     }
     mailmessage * msg = 0;
     char*data=0;
     size_t size;
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder!");
         return result;
     }
     r = mailsession_get_message(m_storage->sto_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error fetching mail %i").arg(mail->getNumber()));
         return 0;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error fetching mail %i").arg(mail->getNumber()));
         if (msg) mailmessage_free(msg);
         return 0;
     }
     result = new encodedString(data,size);
     if (msg) mailmessage_free(msg);
     return result;
 }
 
 void MHwrapper::deleteMails(const QString & mailbox,const QValueList<RecMailP> &target)
 {
     QString f = buildPath(mailbox);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("deleteMails: error selecting folder!");
         return;
     }
     QValueList<RecMailP>::ConstIterator it;
     for (it=target.begin(); it!=target.end();++it) {
         r = mailsession_remove_message(m_storage->sto_session,(*it)->getNumber());
         if (r != MAIL_NO_ERROR) {
             qDebug("error deleting mail");
             break;
         }
     }
 }
 
 int MHwrapper::deleteAllMail(const FolderP&tfolder)
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     int res = 1;
     if (!tfolder) return 0;
     int r = mailsession_select_folder(m_storage->sto_session,(char*)tfolder->getName().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder!");
         return 0;
     }
     mailmessage_list*l=0;
     r = mailsession_get_messages_list(m_storage->sto_session,&l);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error message list");
         res = 0;
     }
     unsigned j = 0;
     for(unsigned int i = 0 ; l!= 0 && res==1 && i < carray_count(l->msg_tab) ; ++i) {
         mailmessage * msg;
         msg = (mailmessage*)carray_get(l->msg_tab, i);
         j = msg->msg_index;
         r = mailsession_remove_message(m_storage->sto_session,j);
         if (r != MAIL_NO_ERROR) {
             Global::statusMessage(tr("Error deleting mail %1").arg(i+1));
             res = 0;
             break;
         }
     }
     if (l) mailmessage_list_free(l);
     return res;
 }
 
 int MHwrapper::deleteMbox(const FolderP&tfolder)
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     if (!tfolder) return 0;
     if (tfolder->getName()=="/" || tfolder->getName().isEmpty()) return 0;
 
     int r = mailsession_delete_folder(m_storage->sto_session,(char*)tfolder->getName().latin1());
 
     if (r != MAIL_NO_ERROR) {
         qDebug("error deleting mail box");
         return 0;
     }
     QString cmd = "rm -rf "+tfolder->getName();
     QStringList command;
     command << "/bin/sh";
     command << "-c";
     command << cmd.latin1();
     OProcess *process = new OProcess();
 
-    connect(process, SIGNAL(processExited(OProcess*)),
+    connect(process, SIGNAL(processExited(Opie::Core::OProcess*)),
             this, SLOT( processEnded(OProcess*)));
-    connect(process, SIGNAL( receivedStderr(OProcess*,char*,int)),
+    connect(process, SIGNAL( receivedStderr(Opie::Core::OProcess*,char*,int)),
             this, SLOT( oprocessStderr(OProcess*,char*,int)));
 
     *process << command;
     removeMboxfailed = false;
     if(!process->start(OProcess::Block, OProcess::All) ) {
         qDebug("could not start process");
         return 0;
     }
     qDebug("mail box deleted");
     return 1;
 }
 
 void MHwrapper::processEnded(OProcess *p)
 {
     if (p) delete p;
 }
 
 void MHwrapper::oprocessStderr(OProcess*, char *buffer, int )
 {
     QString lineStr = buffer;
     QMessageBox::warning( 0, tr("Error"), lineStr ,tr("Ok") );
     removeMboxfailed = true;
 }
 
 void MHwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     QString f = buildPath(mailbox);
     int r = mailsession_status_folder(m_storage->sto_session,(char*)f.latin1(),&target_stat.message_count,
             &target_stat.message_recent,&target_stat.message_unseen);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error retrieving status"));
     }
 }
 
 MAILLIB::ATYPE MHwrapper::getType()const
 {
     return MAILLIB::A_MH;
 }
 
 const QString&MHwrapper::getName()const
 {
     return MHName;
 }
 void MHwrapper::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     if (targetWrapper != this) {
         qDebug("Using generic");
         Genericwrapper::mvcpMail(mail,targetFolder,targetWrapper,moveit);
         return;
     }
     qDebug("Using internal routines for move/copy");
     QString tf = buildPath(targetFolder);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r != MAIL_NO_ERROR) {
         qDebug("Error selecting source mailbox");
         return;
     }
     if (moveit) {
         r = mailsession_move_message(m_storage->sto_session,mail->getNumber(),(char*)tf.latin1());
     } else {
         r = mailsession_copy_message(m_storage->sto_session,mail->getNumber(),(char*)tf.latin1());
     }
     if (r != MAIL_NO_ERROR) {
         qDebug("Error copy/moving mail internal (%i)",r);
     }
 }
 
 void MHwrapper::mvcpAllMails(const FolderP&fromFolder,
     const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     if (targetWrapper != this) {
         qDebug("Using generic");
         Genericwrapper::mvcpAllMails(fromFolder,targetFolder,targetWrapper,moveit);
         return;
     }
     if (!fromFolder) return;
     int r = mailsession_select_folder(m_storage->sto_session,(char*)fromFolder->getName().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting source folder!");
         return;
     }
     QString tf = buildPath(targetFolder);
     mailmessage_list*l=0;
     r = mailsession_get_messages_list(m_storage->sto_session,&l);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error message list");
     }
     unsigned j = 0;
     for(unsigned int i = 0 ; l!= 0 && i < carray_count(l->msg_tab) ; ++i) {
         mailmessage * msg;
         msg = (mailmessage*)carray_get(l->msg_tab, i);
         j = msg->msg_index;
         if (moveit) {
             r = mailsession_move_message(m_storage->sto_session,j,(char*)tf.latin1());
         } else {
             r = mailsession_copy_message(m_storage->sto_session,j,(char*)tf.latin1());
         }
         if (r != MAIL_NO_ERROR) {
             qDebug("Error copy/moving mail internal (%i)",r);
             break;
         }
     }
     if (l) mailmessage_list_free(l);
 }
diff --git a/noncore/net/mail/libmailwrapper/mhwrapper.h b/noncore/net/mail/libmailwrapper/mhwrapper.h
index 208cf2f..1245507 100644
--- a/noncore/net/mail/libmailwrapper/mhwrapper.h
+++ b/noncore/net/mail/libmailwrapper/mhwrapper.h
@@ -1,60 +1,60 @@
 #ifndef __MH_WRAPPER_H
 #define __MH_WRAPPER_H
 
 #include "maildefines.h"
 
 #include "genericwrapper.h"
 #include <qstring.h>
 
 class encodedString;
 struct mailmbox_folder;
-class OProcess;
+namespace Opie {namespace Core {class Opie::Core::OProcess;}}
 
 class MHwrapper : public Genericwrapper
 {
     Q_OBJECT
 public:
     MHwrapper(const QString & dir,const QString&name);
     virtual ~MHwrapper();
 
-    virtual void listMessages(const QString & mailbox, QValueList<Opie::OSmartPointer<RecMail> > &target );
-    virtual QValueList<Opie::OSmartPointer<Folder> >* listFolders();
+    virtual void listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target );
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
     virtual void mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
-    virtual void mvcpAllMails(const Opie::OSmartPointer<Folder>&fromFolder,
+    virtual void mvcpAllMails(const Opie::Core::OSmartPointer<Folder>&fromFolder,
         const QString&targetFolder,AbstractMail*targetWrapper,bool moveit);
 
-    virtual int createMbox(const QString&folder,const Opie::OSmartPointer<Folder>&f=0,
+    virtual int createMbox(const QString&folder,const Opie::Core::OSmartPointer<Folder>&f=0,
         const QString&d="",bool s=false);
-    virtual int deleteMbox(const Opie::OSmartPointer<Folder>&);
+    virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&);
 
     virtual void storeMessage(const char*msg,size_t length, const QString&folder);
 
     virtual RecBody fetchBody( const RecMailP &mail );
     static void mbox_progress( size_t current, size_t maximum );
 
     virtual encodedString* fetchRawBody(const RecMailP&mail);
-    virtual void deleteMails(const QString & FolderName,const QValueList<Opie::OSmartPointer<RecMail> > &target);
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&);
+    virtual void deleteMails(const QString & FolderName,const QValueList<Opie::Core::OSmartPointer<RecMail> > &target);
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&);
     virtual MAILLIB::ATYPE getType()const;
     virtual const QString&getName()const;
 
 public slots:
     /* for deleting maildirs we are using a system call */
-    virtual void oprocessStderr(OProcess*, char *buffer, int );
-    virtual void processEnded(OProcess *);
+    virtual void oprocessStderr(Opie::Core::OProcess*, char *buffer, int );
+    virtual void processEnded(Opie::Core::OProcess *);
 protected:
     QString buildPath(const QString&p);
     QString MHPath;
     QString MHName;
 
     void init_storage();
     void clean_storage();
 
     bool removeMboxfailed;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/nntpwrapper.cpp b/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
index c0b3eec..9de958d 100644
--- a/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/nntpwrapper.cpp
@@ -1,283 +1,284 @@
 #include "nntpwrapper.h"
 #include "logindialog.h"
 #include "mailtypes.h"
 
 #include <qfile.h>
 
 #include <stdlib.h>
 
 #include <libetpan/libetpan.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 ) {
     qDebug( "NNTP: %i of %i", current, maximum );
 }
 
 
 RecBody NNTPwrapper::fetchBody( const RecMailP &mail ) {
     int err = NEWSNNTP_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     login();
     if ( !m_nntp ) {
         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_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::OSmartPointer<RecMail> > &target )
+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);
     parseList(target,m_nntp->sto_session,which,true);
 }
 
 void NNTPwrapper::login()
 {
     if (account->getOffline())
         return;
     /* we'll hold the line */
     if ( m_nntp != NULL )
         return;
 
     const char *server, *user, *pass;
     QString User,Pass;
     uint16_t port;
     int err = NEWSNNTP_NO_ERROR;
 
     server = account->getServer().latin1();
     port = account->getPort().toUInt();
 
     user = pass = 0;
 
     if ( ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) && account->getLogin() ) {
         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( "NNTP: Login canceled" );
             return;
         }
     } else {
         User = account->getUser().latin1();
         Pass = account->getPassword().latin1();
     }
 
     if (User.isEmpty()) {
         user=0;
         pass = 0;
     } else {
         user=User.latin1();
         pass=Pass.latin1();
     }
     //  bool ssl = account->getSSL();
 
     m_nntp=mailstorage_new(NULL);
 
     int conntypeset = account->ConnectionType();
     int conntype = 0;
     if ( conntypeset == 3 ) {
         conntype = CONNECTION_TYPE_COMMAND;
     } else if ( conntypeset == 2 ) {
         conntype = CONNECTION_TYPE_TLS;
     } else if ( conntypeset == 1 ) {
         conntype = CONNECTION_TYPE_STARTTLS;
     } else if ( conntypeset == 0 ) {
         conntype = CONNECTION_TYPE_TRY_STARTTLS;
     }
 
    nntp_mailstorage_init(m_nntp,(char*)server, port, NULL, CONNECTION_TYPE_PLAIN, NNTP_AUTH_TYPE_PLAIN,
                           (char*)user,(char*)pass,0,0,0);
 
     err = mailstorage_connect( m_nntp );
 
    if (err != NEWSNNTP_NO_ERROR) {
         qDebug( QString( "FEHLERNUMMER %1" ).arg(  err ) );
      //   Global::statusMessage(tr("Error initializing folder"));
         mailstorage_free(m_nntp);
         m_nntp = 0;
 
     }
 
 }
 
 void NNTPwrapper::logout()
 {
     int err = NEWSNNTP_NO_ERROR;
     if ( m_nntp == NULL )
         return;
     mailstorage_free(m_nntp);
    m_nntp = 0;
 }
 
-QValueList<Opie::OSmartPointer<Folder> >* NNTPwrapper::listFolders() {
+QValueList<Opie::Core::OSmartPointer<Folder> >* NNTPwrapper::listFolders() {
 
-    QValueList<Opie::OSmartPointer<Folder> >* folders = new QValueList<Opie::OSmartPointer<Folder> >();
+    QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     QStringList groups;
     if (account) {
         groups = account->getGroups();
     }
     for ( QStringList::Iterator it = groups.begin(); it != groups.end(); ++it ) {
         folders->append(new Folder((*it),"."));
     }
     return folders;
 }
 
 /* we made this method in raw nntp access of etpan and not via generic interface
  * 'cause in that case there will be doubled copy operations. eg. the etpan would
  * copy that stuff into its own structures and we must copy it into useable c++
  * structures for our frontend. this would not make sense, so it is better to reimplement
  * the stuff from generic interface of etpan but copy it direct to qt classes.
  */
 QStringList NNTPwrapper::listAllNewsgroups(const QString&mask) {
     login();
     QStringList res;
     clist *result = 0;
     clistcell *current = 0;
     newsnntp_group_description *group;
 
     if ( m_nntp )   {
         mailsession * session = m_nntp->sto_session;
         newsnntp * news =  ( (  nntp_session_state_data * )session->sess_data )->nntp_session;
         int err = NEWSNNTP_NO_ERROR;
         if (mask.isEmpty()) {
             err = newsnntp_list(news, &result);
         } else {
             /* taken from generic wrapper of etpan */
             QString nmask = mask+".*";
             err = newsnntp_list_active(news, nmask.latin1(), &result);
         }
         if ( err == NEWSNNTP_NO_ERROR && result) {
             for ( current=clist_begin(result);current!=NULL;current=clist_next(current) ) {
                 group = (  newsnntp_group_description* ) current->data;
                 if (!group||!group->grp_name||strlen(group->grp_name)==0) continue;
                 res.append(group->grp_name);
             }
         }
     }
     if (result) {
         newsnntp_list_free(result);
     }
     return res;
 }
 
 void NNTPwrapper::answeredMail(const RecMailP&) {}
 
 void NNTPwrapper::statusFolder(folderStat&target_stat,const QString&) {
     login();
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     if (!m_nntp)
         return;
     int r = mailsession_status_folder(m_nntp->sto_session,0,&target_stat.message_count,
                                       &target_stat.message_recent,&target_stat.message_unseen);
 }
 
 
 encodedString* NNTPwrapper::fetchRawBody(const RecMailP&mail) {
     char*target=0;
     size_t length=0;
     encodedString*res = 0;
     mailmessage * mailmsg = 0;
     int err = mailsession_get_message(m_nntp->sto_session, mail->getNumber(), &mailmsg);
     err = mailmessage_fetch(mailmsg,&target,&length);
     if (mailmsg)
         mailmessage_free(mailmsg);
     if (target) {
         res = new encodedString(target,length);
     }
     return res;
 }
 
 MAILLIB::ATYPE NNTPwrapper::getType()const {
     return account->getType();
 }
 
 const QString&NNTPwrapper::getName()const{
     return account->getAccountName();
 }
 
 void NNTPwrapper::deleteMail(const RecMailP&) {
 }
 
 int NNTPwrapper::deleteAllMail(const FolderP&) {
 }
diff --git a/noncore/net/mail/libmailwrapper/nntpwrapper.h b/noncore/net/mail/libmailwrapper/nntpwrapper.h
index a7e4b95..a87a8e8 100644
--- a/noncore/net/mail/libmailwrapper/nntpwrapper.h
+++ b/noncore/net/mail/libmailwrapper/nntpwrapper.h
@@ -1,48 +1,48 @@
 #ifndef __NNTPWRAPPER
 #define __NNTPWRAPPER
 
 #include "mailwrapper.h"
 #include "genericwrapper.h"
 #include <qstring.h>
 #include <libetpan/clist.h>
 
 class encodedString;
 struct mailstorage;
 struct mailfolder;
 
 class NNTPwrapper : public Genericwrapper
 {
 
  Q_OBJECT
 
 public:
     NNTPwrapper( NNTPaccount *a );
     virtual ~NNTPwrapper();
 
    /* mailbox will be ignored */
-    virtual void listMessages(const QString & mailbox, QValueList<Opie::OSmartPointer<RecMail> > &target );
+    virtual void listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target );
     /* should only get the subscribed one */
-    virtual QValueList<Opie::OSmartPointer<Folder> >* listFolders();
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
     /* mailbox will be ignored */
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
     QStringList listAllNewsgroups(const QString&mask = QString::null);
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&);
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&);
 
     virtual RecBody fetchBody( const RecMailP &mail );
     virtual encodedString* fetchRawBody(const RecMailP&mail);
     virtual void logout();
     virtual MAILLIB::ATYPE getType()const;
     virtual const QString&getName()const;
     static void nntp_progress( size_t current, size_t maximum );
 
 protected:
     void login();
     NNTPaccount *account;
     mailstorage* m_nntp;
 
 
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
index 6737d6c..f5694fe 100644
--- a/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/pop3wrapper.cpp
@@ -1,256 +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
 
+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 ) {
     qDebug( "POP3: %i of %i", current, maximum );
 }
 
 RecBody POP3wrapper::fetchBody( const RecMailP &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_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::OSmartPointer<RecMail> > &target )
+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);
     parseList(target,m_pop3->sto_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 conntypeset = account->ConnectionType();
     int conntype = 0;
     if ( conntypeset == 3 ) {
         conntype = CONNECTION_TYPE_COMMAND;
     } else if ( conntypeset == 2 ) {
         conntype = CONNECTION_TYPE_TLS;
     } else if ( conntypeset == 1 ) {
         conntype = CONNECTION_TYPE_STARTTLS;
     } else if ( conntypeset == 0 ) {
         conntype = CONNECTION_TYPE_TRY_STARTTLS;
     }
 
     //(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);
 
 
     err = mailstorage_connect(m_pop3);
     if (err != MAIL_NO_ERROR) {
         qDebug( QString( "FEHLERNUMMER %1" ).arg(  err ) );
         Global::statusMessage(tr("Error initializing folder"));
         mailstorage_free(m_pop3);
         m_pop3 = 0;
     }
 }
 
 void POP3wrapper::logout()
 {
     if ( m_pop3 == NULL )
         return;
     mailstorage_free(m_pop3);
     m_pop3 = 0;
 }
 
 
-QValueList<Opie::OSmartPointer<Folder> >* POP3wrapper::listFolders() {
-    QValueList<Opie::OSmartPointer<Folder> >* folders = new QValueList<FolderP>();
+QValueList<Opie::Core::OSmartPointer<Folder> >* POP3wrapper::listFolders() {
+    QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<FolderP>();
     FolderP inb=new Folder("INBOX","/");
     folders->append(inb);
     return folders;
 }
 
 void POP3wrapper::deleteMail(const RecMailP&mail) {
     login();
     if (!m_pop3)
         return;
     int err = mailsession_remove_message(m_pop3->sto_session,mail->getNumber());
     if (err != MAIL_NO_ERROR) {
         Global::statusMessage(tr("error deleting mail"));
     }
 }
 
 void POP3wrapper::answeredMail(const RecMailP&) {}
 
 int POP3wrapper::deleteAllMail(const FolderP&) {
     login();
     if (!m_pop3)
         return 0;
     int res = 1;
 
     uint32_t result = 0;
     int err = mailsession_messages_number(m_pop3->sto_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_pop3->sto_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_pop3->sto_session,0,&target_stat.message_count,
                                       &target_stat.message_recent,&target_stat.message_unseen);
     if (r != MAIL_NO_ERROR) {
         qDebug("error getting folter status.");
     }
 }
 
 encodedString* POP3wrapper::fetchRawBody(const RecMailP&mail) {
     char*target=0;
     size_t length=0;
     encodedString*res = 0;
     mailmessage * mailmsg = 0;
     int err = mailsession_get_message(m_pop3->sto_session, mail->getNumber(), &mailmsg);
     err = mailmessage_fetch(mailmsg,&target,&length);
     if (mailmsg)
         mailmessage_free(mailmsg);
     if (target) {
         res = new encodedString(target,length);
     }
     return res;
 }
 
 MAILLIB::ATYPE 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 31eb6f1..c46b941 100644
--- a/noncore/net/mail/libmailwrapper/pop3wrapper.h
+++ b/noncore/net/mail/libmailwrapper/pop3wrapper.h
@@ -1,42 +1,42 @@
 #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, QValueList<Opie::OSmartPointer<RecMail> > &target );
-    virtual QValueList<Opie::OSmartPointer<Folder> >* listFolders();
+    virtual void listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target );
+    virtual QValueList<Opie::Core::OSmartPointer<Folder> >* listFolders();
     /* mailbox will be ignored */
     virtual void statusFolder(folderStat&target_stat,const QString & mailbox="INBOX");
 
     virtual void deleteMail(const RecMailP&mail);
     virtual void answeredMail(const RecMailP&mail);
-    virtual int deleteAllMail(const Opie::OSmartPointer<Folder>&);
+    virtual int deleteAllMail(const Opie::Core::OSmartPointer<Folder>&);
 
     virtual RecBody fetchBody( const RecMailP &mail );
     virtual encodedString* fetchRawBody(const RecMailP&mail);
     virtual void logout();
     virtual MAILLIB::ATYPE 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;
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
index 86673aa..e2cea7a 100644
--- a/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
+++ b/noncore/net/mail/libmailwrapper/smtpwrapper.cpp
@@ -1,454 +1,455 @@
 #include "smtpwrapper.h"
 #include "mailwrapper.h"
 #include "abstractmail.h"
 #include "logindialog.h"
 #include "mailtypes.h"
 #include "sendmailprogress.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;
     char *from, *data;
     size_t size;
 
     from = data = 0;
 
     mailmessage * msg = 0;
     msg = mime_message_init(mail);
     mime_message_set_tmpdir(msg,getenv( "HOME" ));
     int r = mailmessage_fetch(msg,&data,&size);
     mime_message_detach_mime(msg);
     mailmessage_free(msg);
     if (r != MAIL_NO_ERROR || !data) {
         if (data)
             free(data);
         qDebug("Error fetching mime...");
         return;
     }
     msg = 0;
     if (later) {
         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);
     if (data) {
         free(data);
     }
     if (from) {
         free(from);
     }
     if (rcpts)
         smtp_address_list_free( rcpts );
 }
 
 void SMTPwrapper::storeFailedMail(const char*data,unsigned int size, const char*failuremessage)
 {
     if (data) {
         storeMail(data,size,"Sendfailed");
     }
     if (failuremessage) {
         QMessageBox::critical(0,tr("Error sending mail"),
             tr("<center>%1</center>").arg(failuremessage));
     }
 }
 
 int SMTPwrapper::start_smtp_tls()
 {
     if (!m_smtp) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int err = mailesmtp_starttls(m_smtp);
     if (err != MAILSMTP_NO_ERROR) return err;
     mailstream_low * low;
     mailstream_low * new_low;
     low = mailstream_get_low(m_smtp->stream);
     if (!low) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int fd = mailstream_low_get_fd(low);
     if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
         mailstream_low_free(low);
         mailstream_set_low(m_smtp->stream, new_low);
     } else {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     return err;
 }
 
 void SMTPwrapper::connect_server()
 {
     const char *server, *user, *pass;
     bool ssl;
     uint16_t port;
     ssl = false;
     bool try_tls = true;
     bool force_tls=false;
     server = user = pass = 0;
     QString failuretext = "";
 
     if (m_smtp || !m_SmtpAccount) {
         return;
     }
     server = m_SmtpAccount->getServer().latin1();
     if  ( m_SmtpAccount->ConnectionType() == 2 ) {
         ssl = true;
         try_tls = false;
     } else if (m_SmtpAccount->ConnectionType() == 1) {
         force_tls = true;
     }
     int result = 1;
     port = m_SmtpAccount->getPort().toUInt();
 
     m_smtp = mailsmtp_new( 20, &progress );
     if ( m_smtp == NULL ) {
         /* no failure message cause this happens when problems with memory - than we
            we can not display any messagebox */
         return;
     }
 
     int err = MAILSMTP_NO_ERROR;
     qDebug( "Servername %s at port %i", server, port );
     if ( ssl ) {
         qDebug( "SSL session" );
         err = mailsmtp_ssl_connect( m_smtp, server, port );
     } else {
         qDebug( "No SSL session" );
         err = mailsmtp_socket_connect( m_smtp, server, port );
     }
     if ( err != MAILSMTP_NO_ERROR ) {
         qDebug("Error init connection");
         failuretext = tr("Error init SMTP connection: %1").arg(mailsmtpError(err));
         result = 0;
     }
 
     /* switch to tls after init 'cause there it will send the ehlo */
     if (result) {
         err = mailsmtp_init( m_smtp );
         if (err != MAILSMTP_NO_ERROR) {
             result = 0;
             failuretext = tr("Error init SMTP connection: %1").arg(mailsmtpError(err));
         }
     }
 
     if (try_tls) {
         err = start_smtp_tls();
         if (err != MAILSMTP_NO_ERROR) {
             try_tls = false;
         } else {
             err = mailesmtp_ehlo(m_smtp);
         }
     }
 
     if (!try_tls && force_tls) {
         result = 0;
         failuretext = tr("Error init SMTP tls: %1").arg(mailsmtpError(err));
     }
 
     if (result==1 && m_SmtpAccount->getLogin() ) {
         qDebug("smtp with auth");
         if ( m_SmtpAccount->getUser().isEmpty() || m_SmtpAccount->getPassword().isEmpty() ) {
             // get'em
             LoginDialog login( m_SmtpAccount->getUser(),
                 m_SmtpAccount->getPassword(), NULL, 0, true );
             login.show();
             if ( QDialog::Accepted == login.exec() ) {
                 // ok
                 user = login.getUser().latin1();
                 pass = login.getPassword().latin1();
             } else {
                 result = 0;
                 failuretext=tr("Login aborted - storing mail to localfolder");
             }
         } else {
             user = m_SmtpAccount->getUser().latin1();
             pass = m_SmtpAccount->getPassword().latin1();
         }
         qDebug( "session->auth: %i", m_smtp->auth);
         if (result) {
             err = mailsmtp_auth( m_smtp, (char*)user, (char*)pass );
             if ( err == MAILSMTP_NO_ERROR ) {
                 qDebug("auth ok");
             } else {
                 failuretext = tr("Authentification failed");
                 result = 0;
             }
         }
     }
 }
 
 void SMTPwrapper::disc_server()
 {
     if (m_smtp) {
         mailsmtp_quit( m_smtp );
         mailsmtp_free( m_smtp );
         m_smtp = 0;
     }
 }
 
 int SMTPwrapper::smtpSend(char*from,clist*rcpts,const char*data,size_t size )
 {
     int err,result;
     QString failuretext = "";
 
     connect_server();
 
     result = 1;
     if (m_smtp) {
         err = mailsmtp_send( m_smtp, from, rcpts, data, size );
         if ( err != MAILSMTP_NO_ERROR ) {
             failuretext=tr("Error sending mail: %1").arg(mailsmtpError(err));
             result = 0;
         }
     } else {
         result = 0;
     }
 
     if (!result) {
         storeFailedMail(data,size,failuretext);
     } else {
         qDebug( "Mail sent." );
         storeMail(data,size,"Sent");
     }
     return result;
 }
 
-void SMTPwrapper::sendMail(const Opie::OSmartPointer<Mail>&mail,bool later )
+void SMTPwrapper::sendMail(const Opie::Core::OSmartPointer<Mail>&mail,bool later )
 {
     mailmime * mimeMail;
 
     mimeMail = createMimeMail(mail );
     if ( mimeMail == NULL ) {
         qDebug( "sendMail: error creating mime mail" );
     } else {
         sendProgress = new progressMailSend();
         sendProgress->show();
         sendProgress->setMaxMails(1);
         smtpSend( mimeMail,later);
         qDebug("Clean up done");
         sendProgress->hide();
         delete sendProgress;
         sendProgress = 0;
         mailmime_free( mimeMail );
     }
 }
 
 int SMTPwrapper::sendQueuedMail(AbstractMail*wrap,const RecMailP&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());
     }
     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() {
     bool returnValue = true;
 
     qDebug("Sending the queue");
     if (!m_SmtpAccount) {
         qDebug("No smtp account given");
         return false;
     }
 
     bool reset_user_value = false;
     QString localfolders = AbstractMail::defaultLocalfolder();
     AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     if (!wrap) {
         qDebug("memory error");
         return false;
     }
     QString oldPw, oldUser;
     QValueList<RecMailP> mailsToSend;
     QValueList<RecMailP> mailsToRemove;
     QString mbox("Outgoing");
     wrap->listMessages(mbox,mailsToSend);
     if (mailsToSend.count()==0) {
         delete wrap;
         qDebug("No mails to send");
         return false;
     }
 
     oldPw = m_SmtpAccount->getPassword();
     oldUser = m_SmtpAccount->getUser();
     if (m_SmtpAccount->getLogin() && (m_SmtpAccount->getUser().isEmpty() || m_SmtpAccount->getPassword().isEmpty()) ) {
         // get'em
         QString user,pass;
         LoginDialog login( m_SmtpAccount->getUser(), m_SmtpAccount->getPassword(), NULL, 0, true );
         login.show();
         if ( QDialog::Accepted == login.exec() ) {
             // ok
             user = login.getUser().latin1();
             pass = login.getPassword().latin1();
             reset_user_value = true;
             m_SmtpAccount->setUser(user);
             m_SmtpAccount->setPassword(pass);
         } else {
             return true;
         }
     }
 
 
     sendProgress = new progressMailSend();
     sendProgress->show();
     sendProgress->setMaxMails(mailsToSend.count());
 
     while (mailsToSend.count()>0) {
         if (sendQueuedMail(wrap, (*mailsToSend.begin()))==0) {
             QMessageBox::critical(0,tr("Error sending mail"),
                                   tr("Error sending queued mail - breaking"));
             returnValue = false;
             break;
         }
         mailsToRemove.append((*mailsToSend.begin()));
         mailsToSend.remove(mailsToSend.begin());
         sendProgress->setCurrentMails(mailsToRemove.count());
     }
     if (reset_user_value) {
         m_SmtpAccount->setUser(oldUser);
         m_SmtpAccount->setPassword(oldPw);
     }
     Config cfg( "mail" );
     cfg.setGroup( "Status" );
     m_queuedMail = 0;
     cfg.writeEntry( "outgoing", m_queuedMail );
     emit queuedMails( m_queuedMail );
     sendProgress->hide();
     delete sendProgress;
     sendProgress = 0;
     wrap->deleteMails(mbox,mailsToRemove);
     delete wrap;
     return returnValue;
 }
diff --git a/noncore/net/mail/libmailwrapper/smtpwrapper.h b/noncore/net/mail/libmailwrapper/smtpwrapper.h
index 71ae35c..6c5bbe8 100644
--- a/noncore/net/mail/libmailwrapper/smtpwrapper.h
+++ b/noncore/net/mail/libmailwrapper/smtpwrapper.h
@@ -1,63 +1,63 @@
 // -*- Mode: C++; -*-
 #ifndef SMTPwrapper_H
 #define SMTPwrapper_H
 
 #include <qpe/applnk.h>
 
 #include <qbitarray.h>
 #include <qdatetime.h>
 #include <libetpan/clist.h>
 
 #include "settings.h"
 #include "generatemail.h"
 
 #include <opie2/osmartpointer.h>
 
 class SMTPaccount;
 class AbstractMail;
 
 class SMTPwrapper : public Generatemail
 {
     Q_OBJECT
 
 public:
     SMTPwrapper(SMTPaccount * aSmtp);
     virtual ~SMTPwrapper();
-    void sendMail(const Opie::OSmartPointer<Mail>& mail,bool later=false );
+    void sendMail(const Opie::Core::OSmartPointer<Mail>& mail,bool later=false );
     bool flushOutbox();
 
     static progressMailSend*sendProgress;
 
 signals:
     void queuedMails( int );
 
 protected:
     mailsmtp *m_smtp;
     SMTPaccount * m_SmtpAccount;
 
     void connect_server();
     void disc_server();
     int start_smtp_tls();
 
 
     void smtpSend( mailmime *mail,bool later);
 
     static void storeMail(const char*mail, size_t length, const QString&box);
     static QString mailsmtpError( int err );
     static void progress( size_t current, size_t maximum );
 
     int smtpSend(char*from,clist*rcpts,const char*data,size_t size);
 
     void storeMail(mailmime*mail, const QString&box);
 
-    int sendQueuedMail(AbstractMail*wrap,const Opie::OSmartPointer<RecMail>&which);
+    int sendQueuedMail(AbstractMail*wrap,const Opie::Core::OSmartPointer<RecMail>&which);
     void storeFailedMail(const char*data,unsigned int size, const char*failuremessage);
 
     int m_queuedMail;
 
 protected slots:
     void emitQCop( int queued );
 
 };
 
 #endif
diff --git a/noncore/net/mail/libmailwrapper/storemail.cpp b/noncore/net/mail/libmailwrapper/storemail.cpp
index 595e7fc..914a11d 100644
--- a/noncore/net/mail/libmailwrapper/storemail.cpp
+++ b/noncore/net/mail/libmailwrapper/storemail.cpp
@@ -1,90 +1,91 @@
 #include "storemail.h"
 #include "mailwrapper.h"
 #include "settings.h"
 #include "abstractmail.h"
 
 #include <libetpan/libetpan.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::OSmartPointer<Mail>&mail)
+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 ) {
         qDebug( "storeMail: error creating mime mail" );
         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) {
         qDebug("Error fetching mime...");
         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/libmailwrapper/storemail.h b/noncore/net/mail/libmailwrapper/storemail.h
index 80c7431..4433de0 100644
--- a/noncore/net/mail/libmailwrapper/storemail.h
+++ b/noncore/net/mail/libmailwrapper/storemail.h
@@ -1,29 +1,29 @@
 #ifndef __STORE_MAIL_H
 #define __STORE_MAIL_H
 
 #include <qpe/applnk.h>
 
 #include "generatemail.h"
 
 class Account;
 class Mail;
 class AbstractMail;
 
 class Storemail : public Generatemail
 {
     Q_OBJECT
 public:
     Storemail(Account*aAccount,const QString&aFolder);
     Storemail(const QString&dir,const QString&aFolder);
     Storemail(const QString&aFolder);
     virtual ~Storemail();
 
-    int storeMail(const Opie::OSmartPointer<Mail>&mail);
+    int storeMail(const Opie::Core::OSmartPointer<Mail>&mail);
 
 protected:
     Account* m_Account;
     QString m_tfolder;
     AbstractMail*wrapper;
 };
 
 #endif
diff --git a/noncore/net/mail/mail.pro b/noncore/net/mail/mail.pro
index 005a839..926cdbd 100644
--- a/noncore/net/mail/mail.pro
+++ b/noncore/net/mail/mail.pro
@@ -1,66 +1,66 @@
 CONFIG        += qt warn_on debug quick-app
 
 HEADERS         = defines.h \
                editaccounts.h \
                composemail.h \
                accountview.h \
                accountitem.h \
                mainwindow.h \
                viewmail.h \
                viewmailbase.h \
                opiemail.h \
                mailistviewitem.h \
                settingsdialog.h \
                statuswidget.h \
                newmaildir.h \
                selectstore.h \
                selectsmtp.h \
                nntpgroups.h \
                nntpgroupsdlg.h
                
 SOURCES         = main.cpp \
                opiemail.cpp \
                mainwindow.cpp \
                accountview.cpp \
                accountitem.cpp \
                composemail.cpp \
                addresspicker.cpp \
                editaccounts.cpp \
                viewmail.cpp \
                viewmailbase.cpp \
                mailistviewitem.cpp \
                settingsdialog.cpp \
                statuswidget.cpp \
                newmaildir.cpp \
                selectstore.cpp \
                selectsmtp.cpp \
                nntpgroups.cpp \
                nntpgroupsdlg.cpp
                
 INTERFACES     = editaccountsui.ui \
                selectmailtypeui.ui \
                imapconfigui.ui \
                pop3configui.ui \
                nntpconfigui.ui \
                smtpconfigui.ui \
                addresspickerui.ui \
                composemailui.ui \
                settingsdialogui.ui \
                statuswidgetui.ui \
                newmaildirui.ui \
                selectstoreui.ui \
                nntpgroupsui.ui
 	
 
-INCLUDEPATH += $(OPIEDIR)/include
+INCLUDEPATH += $(OPIEDIR)/include /usr/local/include
 
 CONFTEST = $$system( echo $CONFIG_TARGET_MACOSX )
 contains( CONFTEST, y ){
     LIBS        += -lqpe -lopieui2 -lopiecore2 -lopiepim2 -lopiedb2 -lmailwrapper -liconv
 }else{
     LIBS        += -lqpe -lopieui2 -lopiecore2 -lopiepim2 -lopiedb2 -lmailwrapper
 }
 
 TARGET       = opiemail
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/net/mail/main.cpp b/noncore/net/mail/main.cpp
index 54ac7fb..4942083 100644
--- a/noncore/net/mail/main.cpp
+++ b/noncore/net/mail/main.cpp
@@ -1,5 +1,7 @@
 #include <opie2/oapplicationfactory.h>
 
 #include "opiemail.h"
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<OpieMail> )
diff --git a/noncore/net/mail/taskbarapplet/mailapplet.cpp b/noncore/net/mail/taskbarapplet/mailapplet.cpp
index de32007..f672a36 100644
--- a/noncore/net/mail/taskbarapplet/mailapplet.cpp
+++ b/noncore/net/mail/taskbarapplet/mailapplet.cpp
@@ -1,145 +1,145 @@
 #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/odevice.h>
 
 #include <libmailwrapper/settings.h>
 
 #include "mailapplet.h"
 
-using namespace Opie;
+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 );
     int newMailsOld = m_newMails;
     m_newMails = stat.message_unseen;
     qDebug( QString( "test %1" ).arg( m_newMails ) );
     if ( m_newMails > 0 &&  newMailsOld != m_newMails  ) {
         ODevice *device = ODevice::inst();
         if ( isHidden() )
             show();
         if ( m_config->readBoolEntry( "BlinkLed", true ) ) {
             if ( !device->ledList().isEmpty() ) {
                 OLed led = ( device->ledList().contains( Led_Mail ) ) ? Led_Mail : device->ledList()[0];
                 device->setLedState( led, device->ledStateList( led ).contains( Led_BlinkSlow ) ? Led_BlinkSlow : Led_On );
             }
         }
         if ( m_config->readBoolEntry( "PlaySound", false ) )
             device->playAlarmSound();
 
         Config cfg( "mail" );
         cfg.setGroup( "Status" );
         cfg.writeEntry( "newMails", m_newMails );
         QCopEnvelope env( "QPE/Pim", "newMails(int)" );
         env <<  m_newMails;
         repaint( true );
 
     } else {
         ODevice *device = ODevice::inst();
         if ( !isHidden() )
             hide();
         if ( !device->ledList().isEmpty() ) {
             OLed led = ( device->ledList().contains( Led_Mail ) ) ? Led_Mail : device->ledList()[0];
             device->setLedState( led, Led_Off );
         }
 
         if ( newMailsOld != m_newMails ) {
             Config cfg( "mail" );
             cfg.setGroup( "Status" );
             cfg.writeEntry( "newMails", m_newMails );
             QCopEnvelope env( "QPE/Pim", "newMails(int)" );
             env <<  m_newMails;
         }
     }
 }
diff --git a/noncore/net/mail/viewmail.cpp b/noncore/net/mail/viewmail.cpp
index 894a386..f00d2cb 100644
--- a/noncore/net/mail/viewmail.cpp
+++ b/noncore/net/mail/viewmail.cpp
@@ -1,415 +1,416 @@
 #include "composemail.h"
 #include "viewmail.h"
 
 /* OPIE */
 #include <libmailwrapper/settings.h>
 #include <libmailwrapper/abstractmail.h>
 #include <libmailwrapper/mailtypes.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;
 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( RecBody 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;
     }
 
     {
         /* I did not found a method to make a CONTENT reset on a QTextStream
            so I use this construct that the stream will re-constructed in each
            loop. To let it work, the textstream is packed into a own area of
            code is it will be destructed after finishing its small job.
         */
         QTextOStream o(&fsize);
         if (w>0) o.precision(2); else o.precision(0);
         o.setf(QTextStream::fixed);
         o << s << " " << q << "Byte";
     }
 
     curItem=new AttachItem(attachments,curItem,type,"Mailbody","",fsize,-1,body.Description().Positionlist());
     QString filename = "";
 
     for (unsigned int i = 0; i < body.Parts().count();++i)
     {
         filename = "";
         type = body.Parts()[i].Type()+"/"+body.Parts()[i].Subtype();
         part_plist_t::ConstIterator it = body.Parts()[i].Parameters().begin();
         for (;it!=body.Parts()[i].Parameters().end();++it)
         {
             qDebug(it.key());
             if (it.key().lower()=="name")
             {
                 filename=it.data();
             }
         }
         s = body.Parts()[i].Size();
         w = 0;
         while (s>1024)
         {
             s/=1024;
             ++w;
             if (w>=2) break;
         }
         switch(w)
         {
         case 1:
             q="k";
             break;
         case 2:
             q="M";
             break;
         default:
             q="";
             break;
         }
         QTextOStream o(&fsize);
         if (w>0) o.precision(2); else o.precision(0);
         o.setf(QTextStream::fixed);
         o << s << " " << q << "Byte";
         desc = body.Parts()[i].Description();
         parentItem = searchParent(body.Parts()[i].Positionlist());
         if (parentItem)
         {
             AttachItem*temp = lastChild(parentItem);
             if (temp) curItem = temp;
             curItem=new AttachItem(parentItem,curItem,type,desc,filename,fsize,i,body.Parts()[i].Positionlist());
             attachments->setRootIsDecorated(true);
             curItem = parentItem;
         }
         else
         {
             curItem=new AttachItem(attachments,curItem,type,desc,filename,fsize,i,body.Parts()[i].Positionlist());
         }
     }
 }
 
 
 void ViewMail::slotShowHtml( bool state )
 {
     m_showHtml = state;
     setText();
 }
 
 void ViewMail::slotItemClicked( QListViewItem * item , const QPoint & point, int )
 {
     if (!item )
         return;
 
     if (  ( ( AttachItem* )item )->Partnumber() == -1 )
     {
         setText();
         return;
     }
     QPopupMenu *menu = new QPopupMenu();
     int ret=0;
 
     if ( item->text( 0 ).left( 5 ) == "text/" || item->text(0)=="message/rfc822" )
     {
         menu->insertItem( tr( "Show Text" ), 1 );
     }
     menu->insertItem( tr( "Save Attachment" ),  0 );
     menu->insertSeparator(1);
 
     ret = menu->exec( point, 0 );
 
     switch(ret)
     {
     case 0:
         {
             MimeTypes types;
             types.insert( "all", "*" );
-            QString str = Opie::OFileDialog::getSaveFileName( 1,
+            QString str = OFileDialog::getSaveFileName( 1,
                           "/", item->text( 2 )  , types, 0 );
 
             if( !str.isEmpty() )
             {
                 encodedString*content = m_recMail->Wrapper()->fetchDecodedPart( m_recMail, m_body.Parts()[ ( ( AttachItem* )item )->Partnumber() ] );
                 if (content)
                 {
                     QFile output(str);
                     output.open(IO_WriteOnly);
                     output.writeBlock(content->Content(),content->Length());
                     output.close();
                     delete content;
                 }
             }
         }
         break ;
 
     case 1:
         if (  ( ( AttachItem* )item )->Partnumber() == -1 )
         {
             setText();
         }
         else
         {
             if (  m_recMail->Wrapper() != 0l )
             { // make sure that there is a wrapper , even after delete or simular actions
                 browser->setText( m_recMail->Wrapper()->fetchTextPart( m_recMail, m_body.Parts()[ ( ( AttachItem* )item )->Partnumber() ] ) );
             }
         }
         break;
     }
     delete menu;
 }
 
 
 void ViewMail::setMail( RecMailP mail )
 {
 
     m_recMail = mail;
 
     m_mail[0] = mail->getFrom();
     m_mail[1] = mail->getSubject();
     m_mail[3] = mail->getDate();
     m_mail[4] = mail->Msgid();
 
     m_mail2[0] = mail->To();
     m_mail2[1] = mail->CC();
     m_mail2[2] = mail->Bcc();
 
     setText();
 }
 
 
 
 ViewMail::ViewMail( QWidget *parent, const char *name, WFlags fl)
         : ViewMailBase(parent, name, fl), _inLoop(false)
 {
     m_gotBody = false;
     deleted = false;
 
     connect( reply, SIGNAL(activated()), SLOT(slotReply()));
     connect( forward, SIGNAL(activated()), SLOT(slotForward()));
     connect( deleteMail, SIGNAL( activated() ),  SLOT( slotDeleteMail() ) );
     connect( showHtml, SIGNAL( toggled(bool) ), SLOT( slotShowHtml(bool) ) );
 
     attachments->setEnabled(m_gotBody);
     connect( attachments,  SIGNAL( clicked(QListViewItem*,const QPoint&, int) ), SLOT( slotItemClicked(QListViewItem*,const QPoint&, int) ) );
 
     readConfig();
     attachments->setSorting(-1);
 }
 
 void ViewMail::readConfig()
 {
     Config cfg( "mail" );
     cfg.setGroup( "Settings" );
     m_showHtml =  cfg.readBoolEntry( "showHtml", false );
     showHtml->setOn( m_showHtml );
 }
 
 void ViewMail::setText()
 {
 
     QString toString;
     QString ccString;
     QString bccString;
 
     for ( QStringList::Iterator it = ( m_mail2[0] ).begin(); it != ( m_mail2[0] ).end(); ++it )
     {
         toString += (*it);
     }
     for ( QStringList::Iterator it = ( m_mail2[1] ).begin(); it != ( m_mail2[1] ).end(); ++it )
     {
         ccString += (*it);
     }
     for ( QStringList::Iterator it = ( m_mail2[2] ).begin(); it != ( m_mail2[2] ).end(); ++it )
     {
         bccString += (*it);
     }
 
     setCaption( caption().arg( m_mail[0] ) );
 
     m_mailHtml = "<html><body>"
                  "<table width=\"100%\" border=\"0\"><tr bgcolor=\"#FFDD76\"><td>"
                  "<div align=left><b>" + deHtml( m_mail[1] ) + "</b></div>"
                  "</td></tr><tr bgcolor=\"#EEEEE6\"><td>"
                  "<b>" + tr( "From" ) + ": </b><font color=#6C86C0>" + deHtml( m_mail[0] ) + "</font><br>"
                  "<b>" + tr(  "To" ) + ": </b><font color=#6C86C0>" + deHtml( toString ) + "</font><br><b>" +
                  tr( "Cc" ) + ": </b>" + deHtml( ccString ) + "<br>"
                  "<b>" + tr( "Date" ) + ": </b> " +  m_mail[3] +
                  "</td></tr></table><font face=fixed>";
 
     if ( !m_showHtml )
     {
         browser->setText( QString( m_mailHtml) + deHtml( m_mail[2] ) + "</font></html>" );
     }
     else
     {
         browser->setText( QString( m_mailHtml) + m_mail[2] + "</font></html>" );
     }
     // remove later in favor of a real handling
     m_gotBody = true;
 }
 
 
 ViewMail::~ViewMail()
 {
     m_recMail->Wrapper()->cleanMimeCache();
     hide();
 }
 
 void ViewMail::hide()
 {
     QWidget::hide();
 
     if (_inLoop)
     {
         _inLoop = false;
         qApp->exit_loop();
 
     }
 
 }
 
 void ViewMail::exec()
 {
     show();
 
     if (!_inLoop)
     {
         _inLoop = true;
         qApp->enter_loop();
     }
 
 }
 
 QString ViewMail::deHtml(const QString &string)
 {
     QString string_ = string;
     string_.replace(QRegExp("&"), "&amp;");
     string_.replace(QRegExp("<"), "&lt;");
     string_.replace(QRegExp(">"), "&gt;");
     string_.replace(QRegExp("\\n"), "<br>");
     return string_;
 }
 
 void ViewMail::slotReply()
 {
     if (!m_gotBody)
     {
         QMessageBox::information(this, tr("Error"), tr("<p>The mail body is not yet downloaded, so you cannot reply yet."), tr("Ok"));
         return;
     }
 
     QString rtext;
     rtext += QString("* %1 wrote on %2:\n")        // no i18n on purpose
              .arg(  m_mail[0] )
              .arg( m_mail[3] );
 
     QString text = m_mail[2];
     QStringList lines = QStringList::split(QRegExp("\\n"), text);
     QStringList::Iterator it;
     for (it = lines.begin(); it != lines.end(); it++)
     {
         rtext += "> " + *it + "\n";
     }
     rtext += "\n";
 
     QString prefix;
     if ( m_mail[1].find(QRegExp("^Re: .*$")) != -1) prefix = "";
     else prefix = "Re: ";                // no i18n on purpose
 
diff --git a/noncore/net/mail/viewmailbase.cpp b/noncore/net/mail/viewmailbase.cpp
index c2bf08c..cbb98cc 100644
--- a/noncore/net/mail/viewmailbase.cpp
+++ b/noncore/net/mail/viewmailbase.cpp
@@ -1,89 +1,89 @@
 #include <qtextbrowser.h>
 #include <qlistview.h>
 #include <qaction.h>
 #include <qlabel.h>
 #include <qvbox.h>
 
-#include <qpe/qpetoolbar.h>
+#include <qtoolbar.h>
 #include <qmenubar.h>
 #include <qpe/resource.h>
 
 #include "viewmailbase.h"
 //#include "opendiag.h"
 
 ViewMailBase::ViewMailBase(QWidget *parent, const char *name, WFlags fl)
 	: QMainWindow(parent, name, fl)
 {
 	setCaption(tr("E-Mail by %1"));
 	setToolBarsMovable(false);
 
 	toolbar = new QToolBar(this);
   menubar = new QMenuBar( toolbar );
   mailmenu = new QPopupMenu( menubar );
   menubar->insertItem( tr( "Mail" ), mailmenu );
 
 	toolbar->setHorizontalStretchable(true);
 	addToolBar(toolbar);
 
 	QLabel *spacer = new QLabel(toolbar);
 	spacer->setBackgroundMode(QWidget::PaletteButton);
 	toolbar->setStretchableWidget(spacer);
 
 	reply = new QAction(tr("Reply"), QIconSet(Resource::loadPixmap("mail/reply")), 0, 0, this);
 	reply->addTo(toolbar);
  	reply->addTo(mailmenu);
 
 	forward = new QAction(tr("Forward"), QIconSet(Resource::loadPixmap("mail/forward")), 0, 0, this);
 	forward->addTo(toolbar);
 	forward->addTo(mailmenu);
 
 	attachbutton = new QAction(tr("Attachments"), QIconSet(Resource::loadPixmap("mail/attach")), 0, 0, this, 0, true);
 	attachbutton->addTo(toolbar);
 	attachbutton->addTo(mailmenu);
 	connect(attachbutton, SIGNAL(toggled(bool)), SLOT(slotChangeAttachview(bool)));
 
 
         showHtml = new QAction( tr( "Show Html" ), QIconSet( Resource::loadPixmap( "mail/html" ) ), 0, 0, this, 0, true );
         showHtml->addTo( toolbar );
         showHtml->addTo( mailmenu );
 
 	deleteMail = new QAction(tr("Delete Mail"), QIconSet(Resource::loadPixmap("trash")), 0, 0, this);
 	deleteMail->addTo(toolbar);
 	deleteMail->addTo(mailmenu);
 
 	QVBox *view = new QVBox(this);
 	setCentralWidget(view);
 
 	attachments = new QListView(view);
 	attachments->setMinimumHeight(90);
 	attachments->setMaximumHeight(90);
 	attachments->setAllColumnsShowFocus(true);
 	attachments->addColumn("Mime Type", 60);
 	attachments->addColumn(tr("Description"), 100);
 	attachments->addColumn(tr("Filename"), 80);
     attachments->addColumn(tr("Size"), 80);
     attachments->setSorting(-1);
 	attachments->hide();
 
 	browser = new QTextBrowser(view);
 
 //	openDiag = new OpenDiag(view);
 //	openDiag->hide();
 
 }
 
 void ViewMailBase::slotChangeAttachview(bool state)
 {
 	if (state) attachments->show();
 	else attachments->hide();
 }
 
 void ViewMailBase::keyPressEvent ( QKeyEvent * e )
 {
     if( e->key()==Qt::Key_Escape ) {
         close();
         e->accept();
         return;
     }
     QWidget::keyPressEvent(e);
 }
diff --git a/noncore/net/opieftp/main.cpp b/noncore/net/opieftp/main.cpp
index d9da4b2..330ca52 100644
--- a/noncore/net/opieftp/main.cpp
+++ b/noncore/net/opieftp/main.cpp
@@ -1,16 +1,18 @@
 
 /***************************************************************************
+
                           main.cpp  -  description
                              -------------------
     begin                : March 10, 2002
     copyright            : (C) 2002 by llornkcor
     email                : ljp@llornkcor.com
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #include <opie2/oapplicationfactory.h>
 #include "opieftp.h"
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<OpieFtp> )
diff --git a/noncore/net/opieirc/config.in b/noncore/net/opieirc/config.in
index 7c6949d..38fa347 100644
--- a/noncore/net/opieirc/config.in
+++ b/noncore/net/opieirc/config.in
@@ -1,4 +1,4 @@
   config OPIEIRC
     boolean "opie-irc (chat via your favorite IRC server)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE
+    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIEUI2 && LIBQTAUX
diff --git a/noncore/net/opieirc/ircsettings.cpp b/noncore/net/opieirc/ircsettings.cpp
index f69d2c4..13fcc24 100644
--- a/noncore/net/opieirc/ircsettings.cpp
+++ b/noncore/net/opieirc/ircsettings.cpp
@@ -1,108 +1,110 @@
 
 #include "ircsettings.h"
 #include "irctab.h"
 
 /* OPIE */
-#include <opie/ocolorbutton.h>
-#include <opie/otabwidget.h>
+#include <opie2/ocolorbutton.h>
+#include <opie2/otabwidget.h>
 #include <qpe/qpeapplication.h>
 
 /* QT */
 #include <qvalidator.h>
 #include <qwhatsthis.h>
 
+using namespace Opie;
+using namespace Opie::Ui;
 IRCSettings::IRCSettings(QWidget* parent, const char* name, bool modal, WFlags) : QDialog(parent, name, modal, WStyle_ContextHelp)
 {
     setCaption(tr("Settings") );
     m_config = new Config("OpieIRC");
     m_config->setGroup("OpieIRC");
     QHBoxLayout *l = new QHBoxLayout(this, 2, 2);
     OTabWidget *tw = new OTabWidget(this);
     l->addWidget(tw);
     /* General Configuration */
     QWidget *genwidget = new QWidget(tw);
     QGridLayout *layout = new QGridLayout(genwidget, 1, 2, 5, 0);
     QLabel *label = new QLabel(tr("Lines displayed :"), genwidget);
     layout->addWidget(label, 0, 0);
     m_lines = new QLineEdit(m_config->readEntry("Lines", "100"), genwidget);
     QWhatsThis::add(m_lines, tr("Amount of lines to be displayed in chats before old lines get deleted - this is necessary to restrain memory consumption. Set to 0 if you don't need this"));
     QIntValidator *validator = new QIntValidator(this);
     validator->setTop(10000);
     validator->setBottom(0);
     m_lines->setValidator(validator);
     layout->addWidget(m_lines, 0, 1);
     tw->addTab(genwidget, "opieirc/settings", tr("General"));
 
     /* Color configuration */
     QScrollView *view = new QScrollView(this);
     view->setResizePolicy(QScrollView::AutoOneFit);
     view->setFrameStyle( QFrame::NoFrame );
     QWidget *widget = new QWidget(view->viewport());
     view->addChild(widget);
     layout = new QGridLayout(widget, 7, 2, 5, 0);
     label = new QLabel(tr("Background color :"), widget);
     layout->addWidget(label, 0, 0);
     m_background = new OColorButton(widget, m_config->readEntry("BackgroundColor", "#FFFFFF"));
     QWhatsThis::add(m_background, tr("Background color to be used in chats"));
     layout->addWidget(m_background, 0, 1);
     label = new QLabel(tr("Normal text color :"), widget);
     layout->addWidget(label, 1, 0);
     m_text = new OColorButton(widget, m_config->readEntry("TextColor", "#000000"));
     QWhatsThis::add(m_text, tr("Text color to be used in chats"));
     layout->addWidget(m_text, 1, 1);
     label = new QLabel(tr("Error color :"), widget);
     layout->addWidget(label, 2, 0);
     m_error = new OColorButton(widget, m_config->readEntry("ErrorColor", "#FF0000"));
     QWhatsThis::add(m_error, tr("Text color to be used to display errors"));
     layout->addWidget(m_error, 2, 1);
     label = new QLabel(tr("Text written by yourself :"), widget);
     layout->addWidget(label, 3, 0);
     m_self = new OColorButton(widget, m_config->readEntry("SelfColor", "#CC0000"));
     QWhatsThis::add(m_self, tr("Text color to be used to identify text written by yourself"));
     layout->addWidget(m_self, 3, 1);
     label = new QLabel(tr("Text written by others :"), widget);
     layout->addWidget(label, 4, 0);
     m_other = new OColorButton(widget, m_config->readEntry("OtherColor", "#0000BB"));
     QWhatsThis::add(m_other, tr("Text color to be used to identify text written by others"));
     layout->addWidget(m_other, 4, 1);
     label = new QLabel(tr("Text written by the server :"), widget);
     layout->addWidget(label, 5, 0);
     m_server = new OColorButton(widget, m_config->readEntry("ServerColor", "#0000FF"));
     QWhatsThis::add(m_server, tr("Text color to be used to identify text written by the server"));
     layout->addWidget(m_server, 5, 1);
     label = new QLabel(tr("Notifications :"), widget);
     layout->addWidget(label, 6, 0);
     m_notification = new OColorButton(widget, m_config->readEntry("NotificationColor", "#AAE300"));
     QWhatsThis::add(m_notification, tr("Text color to be used to display notifications"));
     layout->addWidget(m_notification, 6, 1);
     tw->addTab(view, "opieirc/colors", tr("Colors"));
     tw->setCurrentTab( genwidget );
 
     QPEApplication::showDialog( this );
 }
 
 void IRCSettings::accept()
 {
     IRCTab::m_backgroundColor = m_background->color().name();
     IRCTab::m_textColor = m_text->color().name();
     IRCTab::m_errorColor = m_error->color().name();
     IRCTab::m_selfColor = m_self->color().name();
     IRCTab::m_otherColor = m_other->color().name();
     IRCTab::m_serverColor = m_server->color().name();
     IRCTab::m_notificationColor = m_notification->color().name();
     IRCTab::m_maxLines = m_lines->text().toInt();
     m_config->writeEntry("BackgroundColor", IRCTab::m_backgroundColor);
     m_config->writeEntry("TextColor", IRCTab::m_textColor);
     m_config->writeEntry("ErrorColor", IRCTab::m_errorColor);
     m_config->writeEntry("SelfColor", IRCTab::m_selfColor);
     m_config->writeEntry("OtherColor", IRCTab::m_otherColor);
     m_config->writeEntry("ServerColor", IRCTab::m_serverColor);
     m_config->writeEntry("NotificationColor", IRCTab::m_notificationColor);
     m_config->writeEntry("Lines", m_lines->text());
     QDialog::accept();
 }
 
 IRCSettings::~IRCSettings()
 {
     delete m_config;
 }
diff --git a/noncore/net/opieirc/ircsettings.h b/noncore/net/opieirc/ircsettings.h
index cb8d896..56e667b 100644
--- a/noncore/net/opieirc/ircsettings.h
+++ b/noncore/net/opieirc/ircsettings.h
@@ -1,49 +1,51 @@
 /*
     OpieIRC - An embedded IRC client
     Copyright (C) 2002 Wenzel Jakob
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 */
 
 #ifndef __IRCSETTINGS_H
 #define __IRCSETTINGS_H
 
 #include <qpe/config.h>
 #include <qdialog.h>
 #include <qlineedit.h>
 
+namespace Opie {
 class OColorButton;
+}
 
 class IRCSettings : public QDialog {
     Q_OBJECT
 public:
     IRCSettings(QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags f = 0);
     ~IRCSettings();
 protected slots:
     void accept();
 protected:
     Config       *m_config;
-    OColorButton *m_background;
-    OColorButton *m_text;
-    OColorButton *m_error;
-    OColorButton *m_self;
-    OColorButton *m_server;
-    OColorButton *m_other;
-    OColorButton *m_notification;
+    Opie::OColorButton *m_background;
+    Opie::OColorButton *m_text;
+    Opie::OColorButton *m_error;
+    Opie::OColorButton *m_self;
+    Opie::OColorButton *m_server;
+    Opie::OColorButton *m_other;
+    Opie::OColorButton *m_notification;
     QLineEdit    *m_lines;
 };
 
 #endif /* __IRCSETTINGS_H */
diff --git a/noncore/net/opieirc/main.cpp b/noncore/net/opieirc/main.cpp
index da38024..f3cbecc 100644
--- a/noncore/net/opieirc/main.cpp
+++ b/noncore/net/opieirc/main.cpp
@@ -1,6 +1,7 @@
 #include "mainwindow.h"
 
-#include <opie/oapplicationfactory.h>
+#include <opie2/oapplicationfactory.h>
 
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<MainWindow> )
diff --git a/noncore/net/opieirc/opieirc.pro b/noncore/net/opieirc/opieirc.pro
index 537f810..9039ff8 100644
--- a/noncore/net/opieirc/opieirc.pro
+++ b/noncore/net/opieirc/opieirc.pro
@@ -1,25 +1,25 @@
 CONFIG		= qt warn_on release quick-app
 HEADERS		= ircchannel.h ircconnection.h \
               ircmessage.h \
               ircmessageparser.h ircoutput.h \
               ircperson.h ircserver.h ircsession.h \
               mainwindow.h irctab.h ircservertab.h \
               ircchanneltab.h ircchannellist.h \
               ircserverlist.h ircservereditor.h \
               ircquerytab.h ircsettings.h ircmisc.h
 SOURCES		= ircchannel.cpp ircconnection.cpp \
               ircmessage.cpp \
               ircmessageparser.cpp ircoutput.cpp \
               ircperson.cpp ircserver.cpp \
               ircsession.cpp main.cpp mainwindow.cpp \
               irctab.cpp ircservertab.cpp \
               ircchanneltab.cpp ircchannellist.cpp \
               ircserverlist.cpp ircservereditor.cpp \
               ircquerytab.cpp ircsettings.cpp ircmisc.cpp
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH	+= $(OPIEDIR)/include
-LIBS        += -lqpe -lopie
+LIBS        += -lqpe -lopieui2 -lqtaux2
 
 TARGET	= opieirc
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/net/opietooth/applet/bluezapplet.cpp b/noncore/net/opietooth/applet/bluezapplet.cpp
index 817936d..93b2c67 100644
--- a/noncore/net/opietooth/applet/bluezapplet.cpp
+++ b/noncore/net/opietooth/applet/bluezapplet.cpp
@@ -1,221 +1,221 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 Maximilian Reiss <max.reiss@gmx.de>
            .>+-=
  _;:,     .>    :=|.         This library is free software; you can
 .> <,   >  .   <=          redistribute it and/or  modify it under
 :=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%+i>       _;_.
     .i_,=:_.      -<s.       This library is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include "bluezapplet.h"
 #include <qapplication.h>
 
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/config.h>
 #include <qpe/resource.h>
 
-#include <opie/odevice.h>
+#include <opie2/odevice.h>
 
 #include <qpoint.h>
 #include <qpainter.h>
 #include <qlayout.h>
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qtimer.h>
 #include <qpopupmenu.h>
 
 #include <device.h>
 
 using namespace Opie;
 
 namespace OpieTooth {
 
     BluezApplet::BluezApplet( QWidget *parent, const char *name ) : QWidget( parent, name ) {
         setFixedHeight( 18 );
         setFixedWidth( 14 );
         bluezOnPixmap = Resource::loadPixmap( "bluetoothapplet/bluezon" );
         bluezOffPixmap = Resource::loadPixmap( "bluetoothapplet/bluezoff" );
         //    bluezDiscoveryOnPixmap = Resource::loadPixmap( "bluetoothapplet/magglass" );
         startTimer(4000);
         btDevice = 0;
         bluezactive = false;
         bluezDiscoveryActive = false;
 
     }
 
     BluezApplet::~BluezApplet() {
         if ( btDevice ) {
             delete btDevice;
         }
     }
 
     bool BluezApplet::checkBluezStatus() {
         if (btDevice) {
             if (btDevice->isLoaded() ) {
                 return true;
             } else {
                 return false;
             }
         } else {
             return false;
         }
     }
 
     int BluezApplet::setBluezStatus(int c) {
 
         if ( c == 1 ) {
             switch ( ODevice::inst()->model() ) {
             case Model_iPAQ_H39xx:
                 btDevice = new Device( "/dev/tts/1", "bcsp", "921600" );
                 break;
 
 	    case Model_iPAQ_H5xxx:
 	        btDevice = new Device( "/dev/tts/1", "any", "921600" );
 		break;
 
             default:
                 btDevice = new Device( "/dev/ttySB0", "bcsp", "230400" );
                 break;
             }
         } else {
             if ( btDevice ) {
                 delete btDevice;
                 btDevice = 0;
             }
        }
         return 0;
     }
 
     int BluezApplet::checkBluezDiscoveryStatus() {
     }
 
     int BluezApplet::setBluezDiscoveryStatus(int d) {
     }
 
     void BluezApplet::mousePressEvent( QMouseEvent *) {
 
         QPopupMenu *menu = new QPopupMenu();
         QPopupMenu *signal = new QPopupMenu();
         int ret=0;
 
         /* Refresh active state */
         timerEvent( 0 );
 
 
         if (bluezactive) {
             menu->insertItem( tr("Disable Bluetooth"), 0 );
         } else {
             menu->insertItem( tr("Enable Bluetooth"), 1 );
         }
 
         menu->insertItem( tr("Launch manager"), 2 );
 
         menu->insertSeparator(6);
         //menu->insertItem( tr("Signal strength"), signal,  5);
         //menu->insertSeparator(8);
 
         if (bluezDiscoveryActive) {
             menu->insertItem( tr("Disable discovery"), 3 );
         } else {
             menu->insertItem( tr("Enable discovery"), 4 );
         }
 
 
         QPoint p = mapToGlobal( QPoint(1, -menu->sizeHint().height()-1) );
         ret = menu->exec(p, 0);
 
         switch(ret) {
         case 0:
             setBluezStatus(0);
             timerEvent( 0 );
             break;
         case 1:
             setBluezStatus(1);
             timerEvent( 0 );
             break;
         case 2:
             // start bluetoothmanager
             launchManager();
             timerEvent( 0 );
             break;
         case 3:
             setBluezDiscoveryStatus(0);
             timerEvent( 0 );
             break;
         case 4:
             setBluezDiscoveryStatus(1);
             timerEvent(0 );
             break;
             //case 7:
             // With table of currently-detected devices.
         }
 
         delete signal;
         delete menu;
     }
 
 
 /**
  * Launches the bluetooth manager
  */
     void BluezApplet::launchManager() {
         QCopEnvelope e("QPE/System", "execute(QString)");
         e << QString("bluetooth-manager");
     }
 
 /**
  * Refresh timer
  * @param the timer event
  */
     void BluezApplet::timerEvent( QTimerEvent * ) {
         bool oldactive = bluezactive;
         int olddiscovery = bluezDiscoveryActive;
 
         bluezactive = checkBluezStatus();
         bluezDiscoveryActive = checkBluezDiscoveryStatus();
 
         if ((bluezactive != oldactive) || (bluezDiscoveryActive != olddiscovery)) {
             update();
         }
     }
 
 /**
  * Implementation of the paint event
  * @param the QPaintEvent
  */
     void BluezApplet::paintEvent( QPaintEvent* ) {
         QPainter p(this);
         qDebug("paint bluetooth pixmap");
 
         if (bluezactive > 0) {
             p.drawPixmap( 0, 1,  bluezOnPixmap );
         } else {
             p.drawPixmap( 0, 1,  bluezOffPixmap );
         }
 
         if (bluezDiscoveryActive > 0) {
             p.drawPixmap( 0, 1,  bluezDiscoveryOnPixmap );
         }
     }
 };
diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index bae1c47..d913853 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -1,151 +1,153 @@
 
 #include <signal.h>
 
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 #include "device.h"
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 namespace {
   int parsePid( const QCString& par ){
     int id=0;
     QString string( par );
     QStringList list =  QStringList::split( '\n', string );
     for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
     qWarning("parsePID: %s", (*it).latin1() );
       if( !(*it).startsWith("CSR") ){
 	id = (*it).toInt();
 	break;
       }
     }
     return id;
   }
 }
 
 Device::Device(const QString &device, const QString &mode, const QString &speed )
   : QObject(0, "device") {
 
   qWarning("OpieTooth::Device create" );
   m_hci = 0;
   m_process = 0;
   m_attached = false;
   m_device = device;
   m_mode = mode;
   m_speed = speed;
   attach();
 }
 Device::~Device(){
   detach();
 }
 void Device::attach(){
   qWarning("attaching %s %s %s", m_device.latin1(), m_mode.latin1(), m_speed.latin1() );
   if(m_process == 0 ){
     m_output.resize(0);
     qWarning("new process to create" );
     m_process = new OProcess();
     *m_process << "hciattach";
     *m_process << "-p";
     *m_process << m_device << m_mode << m_speed;
-    connect(m_process, SIGNAL( processExited(OProcess*) ),
+    connect(m_process, SIGNAL( processExited(Opie::Core::OProcess*) ),
 	    this, SLOT( slotExited(OProcess* ) ) );
-    connect(m_process, SIGNAL( receivedStdout(OProcess*, char*, int) ),
+    connect(m_process, SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int) ),
 	    this, SLOT(slotStdOut(OProcess*,char*,int ) ) );
-    connect(m_process, SIGNAL(receivedStderr(OProcess*, char*, int ) ),
+    connect(m_process, SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
 	    this, SLOT(slotStdErr(OProcess*,char*,int) ) );
     if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
       qWarning("Could not start" );
       delete m_process;
       m_process = 0;
     }
   };
 }
 void Device::detach(){
   delete m_hci;
   delete m_process;
   // kill the pid we got
   if(m_attached ){
     //kill the pid
     qWarning( "killing" );
     kill(pid, 9);
   }
   qWarning("detached" );
 }
 bool Device::isLoaded()const{
   return m_attached;
 }
 QString Device::devName()const {
   return QString::fromLatin1("hci0");
 };
 void Device::slotExited( OProcess* proc)
 {
   qWarning("prcess exited" );
   if(proc== m_process ){
     qWarning("proc == m_process" );
     if( m_process->normalExit() ){ // normal exit
       qWarning("normalExit" );
       int ret = m_process->exitStatus();
       if( ret == 0 ){ // attached
 	qWarning("attached" );
 	qWarning("Output: %s", m_output.data() );
 	pid = parsePid( m_output );
 	qWarning("Pid = %d", pid );
 	// now hciconfig hci0 up ( determine hciX FIXME)
 	// and call hciconfig hci0 up
 	// FIXME hardcoded to hci0 now :(
 	m_hci = new OProcess( );
 	*m_hci << "hciconfig";
 	*m_hci << "hci0 up";
-	connect(m_hci, SIGNAL( processExited(OProcess*) ),
+	connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
 		this, SLOT( slotExited(OProcess* ) ) );
 	if(!m_hci->start() ){
 	  qWarning("could not start" );
 	  m_attached = false;
 	  emit device("hci0", false );
 	}
       }else{
         qWarning("crass" );
 	m_attached = false;
 	emit device("hci0", false );
 
       }
     }
     delete m_process;
     m_process = 0;
   }else if(proc== m_hci ){
     qWarning("M HCI exited" );
     if( m_hci->normalExit() ){
       qWarning("normal exit" );
       int ret = m_hci->exitStatus();
       if( ret == 0 ){
 	qWarning("attached really really attached" );
 	m_attached = true;
 	emit device("hci0", true );
       }else{
 	qWarning( "failed" );
 	emit device("hci0", false );
 	m_attached = false;
       }
     }// normal exit
     delete m_hci;
     m_hci = 0;
   }
 }
 void Device::slotStdOut(OProcess* proc, char* chars, int len)
 {
   qWarning("std out" );
   if( len <1 ){
     qWarning( "len < 1 " );
     return;
   }
   if(proc == m_process ){
     QCString string( chars, len+1 ); // \0 == +1
     qWarning("output: %s", string.data() );
     m_output.append( string.data() );
   }
 }
 void Device::slotStdErr(OProcess* proc, char* chars, int len)
 {
   qWarning("std err" );
   slotStdOut( proc, chars, len );
 }
diff --git a/noncore/net/opietooth/lib/device.h b/noncore/net/opietooth/lib/device.h
index ce7fccc..f3339fc 100644
--- a/noncore/net/opietooth/lib/device.h
+++ b/noncore/net/opietooth/lib/device.h
@@ -1,88 +1,88 @@
 
 #ifndef OpieToothDevice_H
 #define OpieToothDevice_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qvaluelist.h>
 
 #include <sys/types.h>
 
-class OProcess;
+namespace Opie {namespace Core {class Opie::Core::OProcess;}}
 namespace OpieTooth {
     /**
      *  Device takes care of attaching serial
      *  devices to the blueZ stack.
      *  After attaching it hciconfig ups it
      */
     class Device : public QObject {
 
         Q_OBJECT
 
     public:
 
     /**
      * Brings up an device.
      * Usage example: new Device(/dev/ttySB0, csr)
      *
      * @param &device QString the device name
      * @param &mode QString the mode
      * @param &speed QString the speed of the device, can be left blank
      */
     Device(const QString &device, const QString& mode, const QString& speed);
 
         /**
          * unloads the device
          */
         ~Device();
 
         /**
          * attach the device
          */
         void attach();
 
         /**
          * detach the device
          */
         void detach();
 
         /**
          * Is the device loaded?
          * @return bool, if the device is loaded
 	 */
         bool isLoaded()const;
 
         /**
          * Returns the device name
          * @return QString, the device name
          */
         QString devName()const ; // hci0
 
     signals:
 
         /**
          * Signals devicename and up status
          * @return &device QString, Devicename
          * @return up bool, if the device is up or not.
          */
         void device(const QString& device, bool up );
     private slots:
-        virtual void slotExited( OProcess* );
-        virtual void slotStdOut(OProcess*, char*, int );
-	virtual void slotStdErr(OProcess*, char*, int );
+        virtual void slotExited( Opie::Core::OProcess* );
+        virtual void slotStdOut(Opie::Core::OProcess*, char*, int );
+	virtual void slotStdErr(Opie::Core::OProcess*, char*, int );
     private:
 	class Private;
 	Private *d;
 	QString m_device;
 	bool m_attached:1;
-	OProcess* m_hci;
-	OProcess* m_process;
+	Opie::Core::OProcess* m_hci;
+	Opie::Core::OProcess* m_process;
 	QString m_devId;
 	QString m_mode;
         QString m_speed;
 	pid_t pid;
 	QCString m_output;
     };
 };
 
 #endif
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index c89d325..56156a8 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -1,334 +1,336 @@
 
 
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 #include "parser.h"
 #include "manager.h"
 
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 Manager::Manager( const QString& dev )
   : QObject()
 {
     qWarning("created");
     m_device = dev;
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::Manager( Device* /*dev*/ )
   : QObject()
 {
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::Manager()
   : QObject()
 {
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::~Manager(){
     delete m_hcitool;
     delete m_sdp;
 }
 void Manager::setDevice( const QString& dev ){
     m_device = dev;
 }
 void Manager::setDevice( Device* /*dev*/ ){
 
 }
 void Manager::isAvailable( const QString& device ){
     OProcess* l2ping = new OProcess();
     l2ping->setName( device.latin1() );
     *l2ping << "l2ping" << "-c1" << device;
-    connect(l2ping, SIGNAL(processExited(OProcess* ) ),
+    connect(l2ping, SIGNAL(processExited(Opie::Core::OProcess* ) ),
             this, SLOT(slotProcessExited(OProcess*) ) );
     if (!l2ping->start() ) {
         emit available( device,  false );
         delete l2ping;
     }
 
 }
 
 void Manager::isAvailable( Device* /*dev*/ ){
 
 
 }
 void Manager::searchDevices( const QString& device ){
     qWarning("search devices");
     OProcess* hcitool = new OProcess();
     hcitool->setName( device.isEmpty() ? "hci0" : device.latin1() );
     *hcitool << "hcitool" << "scan";
-    connect( hcitool, SIGNAL(processExited(OProcess*) ) ,
+    connect( hcitool, SIGNAL(processExited(Opie::Core::OProcess*) ) ,
              this, SLOT(slotHCIExited(OProcess* ) ) );
-    connect( hcitool, SIGNAL(receivedStdout(OProcess*, char*, int ) ),
+    connect( hcitool, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ),
              this, SLOT(slotHCIOut(OProcess*, char*, int ) ) );
     if (!hcitool->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning("could not start");
         RemoteDevice::ValueList list;
         emit foundDevices( device, list );
         delete hcitool;
     }
 }
 
 void Manager::searchDevices(Device* /*d*/ ){
 
 
 }
 void Manager::addService(const QString& name ){
     OProcess proc;
     proc << "sdptool" << "add" << name;
     bool bo = true;
     if (!proc.start(OProcess::DontCare ) )
         bo = false;
     emit addedService( name,  bo );
 }
 void Manager::addServices(const QStringList& list){
     QStringList::ConstIterator it;
     for (it = list.begin(); it != list.end(); ++it )
         addService( (*it) );
 }
 void Manager::removeService( const QString& name ){
     OProcess prc;
     prc << "sdptool" << "del" << name;
     bool bo = true;
     if (!prc.start(OProcess::DontCare ) )
         bo = false;
     emit removedService( name,  bo );
 }
 void Manager::removeServices( const QStringList& list){
     QStringList::ConstIterator it;
     for (it = list.begin(); it != list.end(); ++it )
         removeService( (*it) );
 }
 void Manager::searchServices( const QString& remDevice ){
     OProcess *m_sdp =new OProcess();
     *m_sdp << "sdptool" << "browse" << remDevice;
     m_sdp->setName( remDevice.latin1() );
     qWarning("search Services for %s", remDevice.latin1() );
-    connect(m_sdp, SIGNAL(processExited(OProcess*) ),
+    connect(m_sdp, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSDPExited(OProcess* ) ) );
-    connect(m_sdp, SIGNAL(receivedStdout(OProcess*, char*,  int ) ),
+    connect(m_sdp, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*,  int ) ),
             this, SLOT(slotSDPOut(OProcess*, char*, int) ) );
     if (!m_sdp->start(OProcess::NotifyOnExit,  OProcess::AllOutput) ) {
         qWarning("could not start sdptool" );
         delete m_sdp;
         Services::ValueList list;
         emit foundServices( remDevice, list );
     }
 }
 void Manager::searchServices( const RemoteDevice& dev){
     searchServices( dev.mac() );
 }
 QString Manager::toDevice( const QString& /*mac*/ ){
     return QString::null;
 }
 QString Manager::toMac( const QString &/*device*/ ){
     return QString::null;
 }
 void Manager::slotProcessExited(OProcess* proc ) {
     bool conn= false;
     if (proc->normalExit() && proc->exitStatus() == 0 )
         conn = true;
 
     QString name = QString::fromLatin1(proc->name() );
     emit available( name, conn );
     delete proc;
 }
 void Manager::slotSDPOut(OProcess* proc, char* ch, int len)
 {
     QCString str(ch,  len+1 );
     qWarning("SDP:%s", str.data() );
     QMap<QString, QString>::Iterator it;
     it = m_out.find(proc->name() );
     QString string;
     if ( it != m_out.end() ) {
         string = it.data();
     }
     string.append( str );
     m_out.replace( proc->name(), string );
 
 }
 void Manager::slotSDPExited( OProcess* proc)
 {
     qWarning("proc name %s", proc->name() );
     Services::ValueList  list;
     if (proc->normalExit()  ) {
         QMap<QString, QString>::Iterator it = m_out.find( proc->name() );
         if ( it != m_out.end() ) {
 	    qWarning("found process" );
             list = parseSDPOutput( it.data() );
             m_out.remove( it );
         }
     }
     emit foundServices( proc->name(), list );
     delete proc;
 }
 Services::ValueList Manager::parseSDPOutput( const QString& out ) {
     Services::ValueList list;
     qWarning("parsing output" );
     Parser parser( out );
     list = parser.services();
     return list;
 }
 
 void Manager::slotHCIExited(OProcess* proc ) {
     qWarning("process exited");
     RemoteDevice::ValueList list;
     if (proc->normalExit() ) {
         qWarning("normalExit %s",  proc->name() );
         QMap<QString, QString>::Iterator it = m_devices.find(proc->name() );
         if (it != m_devices.end() ) {
             qWarning("!= end ;)");
             list = parseHCIOutput( it.data() );
             m_devices.remove( it );
         }
     }
     emit foundDevices( proc->name(), list );
     delete proc;
 }
 void Manager::slotHCIOut(OProcess* proc,  char* ch,  int len) {
     QCString str( ch, len+1 );
     qWarning("hci: %s",  str.data() );
     QMap<QString, QString>::Iterator it;
     it = m_devices.find( proc->name() );
     qWarning("proc->name %s", proc->name() );
     QString string;
     if (it != m_devices.end() ) {
         qWarning("slotHCIOut ");
         string = it.data();
     }
     string.append( str );
 
     m_devices.replace( proc->name(),  string );
 }
 RemoteDevice::ValueList Manager::parseHCIOutput(const QString& output ) {
     qWarning("parseHCI %s",  output.latin1() );
     RemoteDevice::ValueList list;
     QStringList strList = QStringList::split('\n',  output );
     QStringList::Iterator it;
     QString str;
     for ( it = strList.begin(); it != strList.end(); ++it ) {
         str = (*it).stripWhiteSpace();
         qWarning("OpieTooth %s", str.latin1() );
         int pos = str.findRev(':' );
         if ( pos > 0 ) {
             QString mac = str.left(17 );
             str.remove( 0,  17 );
             qWarning("mac %s",  mac.latin1() );
             qWarning("rest:%s",  str.latin1() );
             RemoteDevice rem( mac , str.stripWhiteSpace() );
             list.append( rem );
         }
     }
     return list;
 }
 
 ////// hcitool cc and hcitool con
 
 /**
  * Create it on the stack as don't care
  * so we don't need to care for it
  * cause hcitool gets reparented
  */
 void Manager::connectTo( const QString& mac) {
     OProcess proc;
     proc << "hcitool";
     proc << "cc";
     proc << mac;
     proc.start(OProcess::DontCare); // the lib does not care at this point
 }
 
 
 void Manager::searchConnections() {
     qWarning("searching connections?");
     OProcess* proc = new OProcess();
     m_hcitoolCon = QString::null;
 
-    connect(proc, SIGNAL(processExited(OProcess*) ),
+    connect(proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotConnectionExited( OProcess*) ) );
-    connect(proc, SIGNAL(receivedStdout(OProcess*, char*, int) ),
+    connect(proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotConnectionOutput(OProcess*, char*, int) ) );
     *proc << "hcitool";
     *proc << "con";
 
     if (!proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         ConnectionState::ValueList list;
         emit connections( list  );
         delete proc;
     }
 }
 void Manager::slotConnectionExited( OProcess* proc ) {
     ConnectionState::ValueList list;
     list = parseConnections( m_hcitoolCon );
     emit connections(list );
     delete proc;
 }
 void Manager::slotConnectionOutput(OProcess* /*proc*/, char* cha, int len) {
     QCString str(cha, len );
     m_hcitoolCon.append( str );
     //delete proc;
 }
 ConnectionState::ValueList Manager::parseConnections( const QString& out ) {
     ConnectionState::ValueList list2;
     QStringList list = QStringList::split('\n',  out );
     QStringList::Iterator it;
     // remove the first line ( "Connections:")
     it = list.begin();
     it = list.remove( it );
     for (; it != list.end(); ++it ) {
         QString row = (*it).stripWhiteSpace();
         QStringList value = QStringList::split(' ', row );
         qWarning("0: %s", value[0].latin1() );
         qWarning("1: %s", value[1].latin1() );
         qWarning("2: %s", value[2].latin1() );
         qWarning("3: %s", value[3].latin1() );
         qWarning("4: %s", value[4].latin1() );
         qWarning("5: %s", value[5].latin1() );
         qWarning("6: %s", value[6].latin1() );
         qWarning("7: %s", value[7].latin1() );
         qWarning("8: %s", value[8].latin1() );
         ConnectionState con;
         con.setDirection( value[0] == QString::fromLatin1("<") ? Outgoing : Incoming );
         con.setConnectionMode( value[1] );
         con.setMac( value[2] );
         con.setHandle( value[4].toInt() );
         con.setState( value[6].toInt() );
         con.setLinkMode( value[8] == QString::fromLatin1("MASTER") ? Master : Client );
         list2.append( con );
     }
     return list2;
 }
 
 void Manager::signalStrength( const QString &mac ) {
 
     OProcess* sig_proc = new OProcess();
 
-    connect(sig_proc, SIGNAL(processExited(OProcess*) ),
+    connect(sig_proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSignalStrengthExited( OProcess*) ) );
-    connect(sig_proc, SIGNAL(receivedStdout(OProcess*, char*, int) ),
+    connect(sig_proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotSignalStrengthOutput(OProcess*, char*, int) ) );
     *sig_proc << "hcitool";
     *sig_proc << "lq";
     *sig_proc << mac;
 
     sig_proc->setName( mac.latin1() );
 
     if (!sig_proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         emit signalStrength( mac, "-1" );
         delete sig_proc;
     }
 }
 
 void Manager::slotSignalStrengthOutput(OProcess* proc, char* cha, int len) {
     QCString str(cha, len );
     QString temp = QString(str).stripWhiteSpace();
     QStringList value = QStringList::split(' ', temp );
     emit signalStrength( proc->name(), value[2].latin1() );
 }
 
 
 void Manager::slotSignalStrengthExited( OProcess* proc ) {
      delete proc;
 }
diff --git a/noncore/net/opietooth/lib/manager.h b/noncore/net/opietooth/lib/manager.h
index abc8ba1..9b1c714 100644
--- a/noncore/net/opietooth/lib/manager.h
+++ b/noncore/net/opietooth/lib/manager.h
@@ -1,173 +1,173 @@
 
 #ifndef OpieToothManager_H
 #define OpieToothManager_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qmap.h>
 #include <qvaluelist.h>
 
 #include "connection.h"
 #include "remotedevice.h"
 #include "services.h"
 
-class OProcess;
+namespace Opie {namespace Core {class Opie::Core::OProcess;}}
 namespace OpieTooth {
     class Device;
     /** Manager manages a blueZ device (hci0 for example)
      *  without Manager you can control the things you
      *  could do from command line in a OO and asynchronus
      *  way.
      */
     class Manager : public QObject {
         Q_OBJECT
     public:
         /** c'tor whichs create a new Manager
          *  @param device is the device to use. Either a mac or blueZ device name
          *
          */
         Manager( const QString &device );
 
         /** c'tor
          * @param dev The Device to be managed
          * We don't care of Device so you need to delete it
          */
         Manager( Device* dev );
 
         /**
          * c'tor
          */
         Manager();
 
         ~Manager();
 
         /** Set the manager to control a new device
          *  @param device the new device to control (hci0 )
          */
         void setDevice( const QString& device );
 
         /**
          * Convience functions for setting a new device
          */
         void setDevice( Device *dev );
 
         /**
          * Wether or not a device is connected. The function
          * is asynchron
          * If device is empty it will take the currently managed
          * device and see if it's up
          * for Remote devices it will ping and see.
          * @param either mac or hciX
          */
         void isAvailable(const QString& device= QString::null );
 
         /**
          * same as above
          */
         void isAvailable(Device *dev );
 
         /** this searchs for devices reachable from the
          *  currently managed device
          *  or from device if @param device is not empty
          */
         void searchDevices(const QString& device= QString::null );
         /** same as above
          *
          */
         void searchDevices(Device *d );
 
         /**
          * This will add the service @param name
          * to the sdpd daemon
          * It will start the daemon if necessary
          */
         void addService(const QString &name );
 
         /**
          * This will add the services @param names
          * to the sdpd daemon
          * It will start the daemon if necessary
          */
         void addServices( const QStringList& names );
 
         /**
          * This removes a service from the sdps
          */
         void removeService(const QString &name );
 
         /**
          * Removes a list from the sdpd
          */
         void removeServices(const QStringList& );
 
         /**
          * search for services on a remote device
          *
          */
         void searchServices( const QString& remDevice );
 
         /**
          * search for services on a remote device
          */
         void searchServices( const RemoteDevice& );
 
         /**
          * Starts to connect to the device
          * in @param
          */
         void connectTo(const QString& );
 
         /**
          * Searches for active connections
          * the result is emitted with the
          * connections signal
          */
         void searchConnections();
 
 	void signalStrength( const QString &mac );
 //// not implemented yet
         /*static*/ QString toDevice( const QString& mac );
         /*static*/ QString toMac( const QString &device );
 //// not implemented yet over
 
     signals:
         // device either mac or dev name
         // the first device is the device which you access
         void available( const QString& device, bool connected );
         void addedService(  const QString& service, bool added );
         void removedService( const QString& service, bool removed );
         void foundServices( const QString& device, Services::ValueList );
         void foundDevices( const QString& device, RemoteDevice::ValueList );
         void connections( ConnectionState::ValueList );
 	void signalStrength( const QString& mac, const QString& strengh );
 
 private slots:
-        void slotProcessExited(OProcess* );
+        void slotProcessExited(Opie::Core::OProcess* );
 
-        void slotSDPExited(OProcess*);
-        void slotSDPOut(OProcess*, char*, int);
+        void slotSDPExited(Opie::Core::OProcess*);
+        void slotSDPOut(Opie::Core::OProcess*, char*, int);
 
-        void slotHCIExited(OProcess* );
-        void slotHCIOut(OProcess*, char*, int );
+        void slotHCIExited(Opie::Core::OProcess* );
+        void slotHCIOut(Opie::Core::OProcess*, char*, int );
 
-        void slotConnectionExited(OProcess* );
-        void slotConnectionOutput(OProcess*, char*, int );
+        void slotConnectionExited(Opie::Core::OProcess* );
+        void slotConnectionOutput(Opie::Core::OProcess*, char*, int );
 
-	void slotSignalStrengthOutput( OProcess*, char*, int );
-	void slotSignalStrengthExited( OProcess* );
+	void slotSignalStrengthOutput( Opie::Core::OProcess*, char*, int );
+	void slotSignalStrengthExited( Opie::Core::OProcess* );
     private:
         Services::ValueList parseSDPOutput( const QString& );
         RemoteDevice::ValueList parseHCIOutput( const QString& );
         ConnectionState::ValueList parseConnections( const QString& );
-        OProcess *m_hcitool;
-        OProcess *m_sdp; // not only one
+        Opie::Core::OProcess *m_hcitool;
+        Opie::Core::OProcess *m_sdp; // not only one
         QString m_device;
 	QMap<QString, int> m_signalStrength;
         QMap<QString, QString> m_out;
         QMap<QString, QString> m_devices;
-	QMap<OProcess*, QString> m_signalMac;
+	QMap<Opie::Core::OProcess*, QString> m_signalMac;
         QString m_hcitoolCon;
     };
 };
 
 #endif
diff --git a/noncore/net/opietooth/lib/startdunconnection.cpp b/noncore/net/opietooth/lib/startdunconnection.cpp
index c3850eb..90ef04a 100644
--- a/noncore/net/opietooth/lib/startdunconnection.cpp
+++ b/noncore/net/opietooth/lib/startdunconnection.cpp
@@ -1,67 +1,69 @@
 
 #include "startdunconnection.h"
 
 using namespace OpieTooth;
 
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 StartDunConnection::StartDunConnection() {
     m_dunConnect = 0l;
     setConnectionType();
 }
 
 StartDunConnection::~StartDunConnection() {
     delete m_dunConnect;
 }
 
 StartDunConnection::StartDunConnection( QString mac )  {
     m_dunConnect = 0l;
     m_mac = mac;
     setConnectionType();
 }
 
 void StartDunConnection::setName( QString name ) {
     m_name = name;
 }
 
 QString StartDunConnection::name()  {
     return m_name;
 }
 
 void StartDunConnection::setConnectionType() {
     m_connectionType = Pan;
 }
 
 StartConnection::ConnectionType StartDunConnection::type() {
     return m_connectionType;
 }
 
 void StartDunConnection::start()  {
     m_dunConnect = new OProcess();
     *m_dunConnect << "dund" << "--listen" << "--connect"  << m_mac;
 
-    connect( m_dunConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_dunConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_dunConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_dunConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_dunConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not start" );
         delete m_dunConnect;
     }
 }
 
 
 void StartDunConnection::slotExited( OProcess* proc ) {
     delete m_dunConnect;
 }
 
 void StartDunConnection::slotStdOut(OProcess* proc, char* chars, int len)
 {}
 
 
 void StartDunConnection::stop()  {
     if ( m_dunConnect )  {
         delete m_dunConnect;
         m_dunConnect = 0l;
     }
 }
 
diff --git a/noncore/net/opietooth/lib/startdunconnection.h b/noncore/net/opietooth/lib/startdunconnection.h
index 43a852a..f6107f6 100644
--- a/noncore/net/opietooth/lib/startdunconnection.h
+++ b/noncore/net/opietooth/lib/startdunconnection.h
@@ -1,40 +1,40 @@
 #ifndef startdunconnection_h
 #define startdunconnection_h
 
 #include <qobject.h>
 #include "connection.h"
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 namespace OpieTooth {
 
     class StartDunConnection : StartConnection {
 
 	Q_OBJECT
 
     public:
 	StartDunConnection();
 	StartDunConnection( QString mac );
 	~StartDunConnection();
 
 	QString name();
 	void setName( QString name );
 	StartConnection::ConnectionType type();
 	void setConnectionType( );
 	void start();
 	void stop();
 
     private:
 	QString m_name;
 	QString m_mac;
 	ConnectionType m_connectionType;
-	OProcess* m_dunConnect;
+	Opie::Core::OProcess* m_dunConnect;
 	
     private slots:
-	void slotExited( OProcess* proc );
-                void slotStdOut( OProcess* proc, char* chars, int len );
+	void slotExited( Opie::Core::OProcess* proc );
+                void slotStdOut( Opie::Core::OProcess* proc, char* chars, int len );
     };
 
  
 }
 
 #endif
diff --git a/noncore/net/opietooth/lib/startpanconnection.cpp b/noncore/net/opietooth/lib/startpanconnection.cpp
index a42b407..fef35d9 100644
--- a/noncore/net/opietooth/lib/startpanconnection.cpp
+++ b/noncore/net/opietooth/lib/startpanconnection.cpp
@@ -1,82 +1,84 @@
 
 #include "startpanconnection.h"
 
 using namespace OpieTooth;
 
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 StartPanConnection::StartPanConnection() {
     m_panConnect = 0l;
     setConnectionType();
 }
 
 StartPanConnection::~StartPanConnection() {
     delete m_panConnect;
 }
 
 StartPanConnection::StartPanConnection( QString mac )  {
     m_panConnect = 0l;
     m_mac = mac;
     setConnectionType();
 }
 
 void StartPanConnection::setName( QString name ) {
     m_name = name;
 }
 
 QString StartPanConnection::name()  {
     return m_name;
 }
 
 void StartPanConnection::setConnectionType() {
     m_connectionType = Pan;
 }
 
 StartConnection::ConnectionType StartPanConnection::type() {
     return m_connectionType;
 }
 
 void StartPanConnection::start()  {
     m_panConnect = new OProcess();
     qDebug( "IM START " + m_mac );
     *m_panConnect << "pand" << "--connect" << m_mac;
 
-    connect( m_panConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_panConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_panConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_panConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_panConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not start" );
         delete m_panConnect;
     }
 }
 
 
 void StartPanConnection::slotExited( OProcess* proc ) {
     delete m_panConnect;
     m_panConnect = 0l;
 }
 
 void StartPanConnection::slotStdOut(OProcess* proc, char* chars, int len)
 {}
 
 
 void StartPanConnection::stop()  {
     if ( m_panConnect )  {
         delete m_panConnect;
         m_panConnect = 0l;
     }
     m_panConnect = new OProcess();
     qDebug("IM STOP " + m_mac);
 
     *m_panConnect << "pand" << "--kill" << m_mac;
 
-    connect( m_panConnect, SIGNAL( processExited(OProcess*) ) ,
+    connect( m_panConnect, SIGNAL( processExited(Opie::Core::OProcess*) ) ,
              this, SLOT( slotExited(OProcess*) ) );
-    connect( m_panConnect, SIGNAL( receivedStdout(OProcess*,char*,int) ),
+    connect( m_panConnect, SIGNAL( receivedStdout(Opie::Core::OProcess*,char*,int) ),
              this, SLOT( slotStdOut(OProcess*,char*,int) ) );
     if (!m_panConnect->start( OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning( "could not stop" );
         delete m_panConnect;
     }
 }
 
diff --git a/noncore/net/opietooth/lib/startpanconnection.h b/noncore/net/opietooth/lib/startpanconnection.h
index 7e5bd95..e12dad0 100644
--- a/noncore/net/opietooth/lib/startpanconnection.h
+++ b/noncore/net/opietooth/lib/startpanconnection.h
@@ -1,40 +1,40 @@
 #ifndef startpanconnection_h
 #define startpanconnection_h
 
 #include <qobject.h>
 #include "connection.h"
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 namespace OpieTooth {
 
     class StartPanConnection : StartConnection {
 
 	Q_OBJECT
 
     public:
 	StartPanConnection();
 	StartPanConnection( QString mac );
 	~StartPanConnection();
 
 	QString name();
 	void setName( QString name );
 	StartConnection::ConnectionType type();
 	void setConnectionType( );
 	void start();
 	void stop();
 
     private:
 	QString m_name;
 	QString m_mac;
 	ConnectionType m_connectionType;
-	OProcess* m_panConnect;
+	Opie::Core::OProcess* m_panConnect;
 	
     private slots:
-	void slotExited( OProcess* proc );
-        void slotStdOut( OProcess* proc, char* chars, int len );
+	void slotExited( Opie::Core::OProcess* proc );
+        void slotStdOut( Opie::Core::OProcess* proc, char* chars, int len );
     };
 
  
 }
 
 #endif
diff --git a/noncore/net/opietooth/manager/main.cpp b/noncore/net/opietooth/manager/main.cpp
index 82aeebd..a96f128 100644
--- a/noncore/net/opietooth/manager/main.cpp
+++ b/noncore/net/opietooth/manager/main.cpp
@@ -1,25 +1,27 @@
 /*
+using namespace Opie::Core;
+using namespace Opie::Core;
  * main.cpp
  *
  * ---------------------
  *
  * begin       : Sun 10 17:20:00 CEST 2002
  * copyright   : (c) 2002 by Maximilian Reiß
  * email       : max.reiss@gmx.de
  *
  */
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "bluebase.h"
 #include <qpe/qpeapplication.h>
-#include <opie/oapplicationfactory.h>
+#include <opie2/oapplicationfactory.h>
 
 OPIE_EXPORT_APP( OApplicationFactory<OpieTooth::BlueBase> )
 
diff --git a/noncore/net/opietooth/manager/obexdialog.cpp b/noncore/net/opietooth/manager/obexdialog.cpp
index 46a0e3d..1ef862a 100644
--- a/noncore/net/opietooth/manager/obexdialog.cpp
+++ b/noncore/net/opietooth/manager/obexdialog.cpp
@@ -1,86 +1,89 @@
 
 #include "obexdialog.h"
 #include <qpushbutton.h>
 #include <qmultilineedit.h>
 #include <qlineedit.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qfileinfo.h>
 
 #include <qpe/resource.h>
 
-#include <opie/oprocess.h>
-#include <opie/ofiledialog.h>
+#include <opie2/oprocess.h>
+#include <opie2/ofiledialog.h>
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Ui;
+using namespace Opie::Core;
 ObexDialog::ObexDialog( QWidget* parent,  const char* name, bool modal, WFlags fl, const QString& device )
     : QDialog( parent, name, modal, fl ) {
 
     if ( !name )
 	setName( "ObexDialog" );
     setCaption( tr( "beam files " ) ) ;
 
     m_device = device;
 
     layout = new QVBoxLayout( this );
 
     QLabel* info = new QLabel( this );
     info->setText( tr("Which file should be beamed?") );
 
     cmdLine = new QLineEdit( this );
 
     QPushButton *browserButton;
     browserButton = new QPushButton( Resource::loadIconSet("fileopen"),"",this,"BrowseButton");
     connect( browserButton, SIGNAL(released() ), this , SLOT(browse() ) );
 
     chNameLine = new QLineEdit( this );
 
     sendButton = new QPushButton( this );
     sendButton->setText( tr( "Send" ) );
 
     layout->addWidget(info);
     layout->addWidget(cmdLine);
     layout->addWidget(browserButton);
     layout->addWidget(chNameLine);
     layout->addWidget(sendButton);
 
     connect( sendButton, SIGNAL( clicked() ), this,  SLOT( sendData() ) );
 
 }
 
 ObexDialog::~ObexDialog() {
 }
 
 void ObexDialog::browse() {
 
     MimeTypes types;
     QStringList all;
     all << "*/*";
     types.insert("All Files", all );
 
     QString str = OFileDialog::getOpenFileName( 1,"/","", types, 0 );
     cmdLine->setText( str );
 
 }
 
 void ObexDialog::sendData() {
     QString fileURL = cmdLine->text();
     QString file = QFileInfo( fileURL ).fileName();
     QString modifiedName = chNameLine->text();
 
        // vom popupmenu beziehen
     OProcess* obexSend = new OProcess();
     if ( !modifiedName.isEmpty() ) {
         *obexSend << "ussp-push" << m_device << fileURL << modifiedName;
     } else {
         *obexSend << "ussp-push" << m_device << fileURL << file;
     }
     if (!obexSend->start(OProcess::DontCare, OProcess::AllOutput) ) {
         qWarning("could not start");
         delete obexSend;
     }
 
 
 
 }
diff --git a/noncore/net/opietooth/manager/obexdialog.h b/noncore/net/opietooth/manager/obexdialog.h
index b3d5e6d..d5b5682 100644
--- a/noncore/net/opietooth/manager/obexdialog.h
+++ b/noncore/net/opietooth/manager/obexdialog.h
@@ -1,39 +1,39 @@
 #ifndef OBEXDIALOG_H
 #define OBEXDIALOG_H
 
 
 #include <qdialog.h>
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 class QVBoxLayout;
 class QPushButton;
 class QMultiLineEdit;
 class QLineEdit;
 
 
 namespace OpieTooth {
 
     class ObexDialog : public QDialog {
 
         Q_OBJECT
 
     public:
         ObexDialog( QWidget* parent = 0, const char* name = 0, bool modal = TRUE, WFlags fl = 0,  const QString& device = 0);
         ~ObexDialog();
 
 
 private slots:
         void browse();
         void sendData();
 
     protected:
         QVBoxLayout* layout;
         QLineEdit* cmdLine;
         QLineEdit* chNameLine;
         QPushButton* sendButton;
     private:
         // Device that is used
         QString m_device;
     };
 }
 #endif
diff --git a/noncore/net/opietooth/manager/pppdialog.cpp b/noncore/net/opietooth/manager/pppdialog.cpp
index 4e58552..870e7fd 100644
--- a/noncore/net/opietooth/manager/pppdialog.cpp
+++ b/noncore/net/opietooth/manager/pppdialog.cpp
@@ -1,68 +1,70 @@
 
 #include "pppdialog.h"
 #include <qpushbutton.h>
 #include <qmultilineedit.h>
 #include <qlineedit.h>
 #include <qlayout.h>
 #include <qlabel.h>
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 using namespace OpieTooth;
 
+using namespace Opie::Core;
+using namespace Opie::Core;
 PPPDialog::PPPDialog( QWidget* parent,  const char* name, bool modal, WFlags fl, const QString& device )
     : QDialog( parent, name, modal, fl ) {
 
     if ( !name )
 	setName( "PPPDialog" );
     setCaption( tr( "ppp connection " ) ) ;
 
     m_device = device;
 
     layout = new QVBoxLayout( this );
 
     QLabel* info = new QLabel( this );
     info->setText( tr("Enter an ppp script name:") );
 
     cmdLine = new QLineEdit( this );
 
     outPut = new QMultiLineEdit( this );
     QFont outPut_font(  outPut->font() );
     outPut_font.setPointSize( 8 );
     outPut->setFont( outPut_font );
     outPut->setWordWrap( QMultiLineEdit::WidgetWidth );
 
     connectButton = new QPushButton( this );
     connectButton->setText( tr( "Connect" ) );
 
     layout->addWidget(info);
     layout->addWidget(cmdLine);
     layout->addWidget(outPut);
     layout->addWidget(connectButton);
 
     connect( connectButton, SIGNAL( clicked() ), this,  SLOT( connectToDevice() ) );
 
 }
 
 PPPDialog::~PPPDialog() {
 }
 
 void PPPDialog::connectToDevice() {
     outPut->clear();
     // vom popupmenu beziehen
     QString connectScript = "/etc/ppp/peers/" + cmdLine->text();
     OProcess* pppDial = new OProcess();
     *pppDial << "pppd" << m_device << "call" << connectScript;
-    connect( pppDial, SIGNAL(receivedStdout(OProcess*,char*,int) ),
+    connect( pppDial, SIGNAL(receivedStdout(Opie::Core::OProcess*,char*,int) ),
                 this, SLOT(fillOutPut(OProcess*,char*,int) ) );
      if (!pppDial->start(OProcess::DontCare, OProcess::AllOutput) ) {
         qWarning("could not start");
         delete pppDial;
     }
 }
 
 void PPPDialog::fillOutPut( OProcess* pppDial, char* cha, int len ) {
     QCString str(cha, len );
     outPut->insertLine( str );
     delete pppDial;
 }
 
diff --git a/noncore/net/opietooth/manager/pppdialog.h b/noncore/net/opietooth/manager/pppdialog.h
index bb8b734..05894e2 100644
--- a/noncore/net/opietooth/manager/pppdialog.h
+++ b/noncore/net/opietooth/manager/pppdialog.h
@@ -1,37 +1,37 @@
 #ifndef PPPDIALOG_H
 #define PPPDIALOG_H
 
 
 #include <qdialog.h>
-#include <opie/oprocess.h>
+#include <opie2/oprocess.h>
 
 class QVBoxLayout;
 class QPushButton;
 class QMultiLineEdit;
 class QLineEdit;
 
 
 namespace OpieTooth {
 
     class PPPDialog : public QDialog {
 
         Q_OBJECT
 
     public:
         PPPDialog( QWidget* parent = 0, const char* name = 0, bool modal = TRUE, WFlags fl = 0, const QString& device = 0);
         ~PPPDialog();
 
     private slots:
         void connectToDevice();
-        void fillOutPut( OProcess* pppDial, char* cha, int len );
+        void fillOutPut( Opie::Core::OProcess* pppDial, char* cha, int len );
     protected:
         QVBoxLayout* layout;
         QLineEdit* cmdLine;
         QPushButton* connectButton;
         QMultiLineEdit* outPut;
 
     private:
         QString m_device;
     };
 }
 #endif
diff --git a/noncore/net/ubrowser/main.cpp b/noncore/net/ubrowser/main.cpp
index 0488cfd..0736f1f 100644
--- a/noncore/net/ubrowser/main.cpp
+++ b/noncore/net/ubrowser/main.cpp
@@ -1,24 +1,26 @@
 /*
 Opie-uBrowser.  a very small web browser, using on QTextBrowser for html display/parsing
 Copyright (C) 2002 Thomas Stephens
 
 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 Public License for more details.
 
 You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
 #include <qpe/qpeapplication.h>
 
 #include "mainview.h"
 
-#include <opie/oapplicationfactory.h>
+#include <opie2/oapplicationfactory.h>
 
+
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<MainView> )
 
diff --git a/noncore/net/wellenreiter/gui/configwindow.cpp b/noncore/net/wellenreiter/gui/configwindow.cpp
index 95b03d0..da39113 100644
--- a/noncore/net/wellenreiter/gui/configwindow.cpp
+++ b/noncore/net/wellenreiter/gui/configwindow.cpp
@@ -1,237 +1,243 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 /* LOCAL */
 #include "configwindow.h"
 #include "mainwindow.h"
 
 /* OPIE */
 #include <opie2/onetwork.h>
 #ifdef QWS
 #include <opie2/oapplication.h>
 #include <opie2/oconfig.h>
 #include <opie2/odevice.h>
 using namespace Opie;
 #endif
 
 /* QT */
 #include <qapplication.h>
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qfile.h>
 #include <qlineedit.h>
 #include <qlayout.h>
 #include <qmap.h>
 #include <qpushbutton.h>
 #include <qtabwidget.h>
 #include <qtoolbutton.h>
 #include <qspinbox.h>
 #include <qtextstream.h>
 
 /* POSIX */
 #include <assert.h>
 
+using namespace Opie::Core;
+using namespace Opie::Net;
+using namespace Opie::Core;
+using namespace Opie::Net;
+using namespace Opie::Core;
+using namespace Opie::Net;
 WellenreiterConfigWindow* WellenreiterConfigWindow::_instance = 0;
 
 WellenreiterConfigWindow::WellenreiterConfigWindow( QWidget * parent, const char * name, WFlags f )
            :WellenreiterConfigBase( parent, name, true, f )
 {
     _devicetype[ "cisco" ] = DEVTYPE_CISCO;
     _devicetype[ "wlan-ng" ] = DEVTYPE_WLAN_NG;
     _devicetype[ "hostap" ] = DEVTYPE_HOSTAP;
     _devicetype[ "orinoco" ] = DEVTYPE_ORINOCO;
     _devicetype[ "<manual>" ] = DEVTYPE_MANUAL;
     _devicetype[ "<file>" ] = DEVTYPE_FILE;
 
     // gather possible interface names from ONetwork
     ONetwork* net = ONetwork::instance();
     ONetwork::InterfaceIterator it = net->iterator();
     while ( it.current() )
     {
         if ( it.current()->isWireless() )
             interfaceName->insertItem( it.current()->name() );
         ++it;
     }
 
     load();
 
     #ifdef Q_WS_X11 // We're on X11: adding an Ok-Button for the Dialog here
     QPushButton* okButton = new QPushButton( "ok", this );
     okButton->show();
     WellenreiterConfigBaseLayout->addWidget( okButton, 0, 3 ); //FIXME: rename this in configbase.ui
     connect( okButton, SIGNAL( clicked() ), this, SLOT( accept() ) );
     #endif
 
     WellenreiterConfigWindow::_instance = this;
 
     connect( deviceType, SIGNAL( activated(int) ), this, SLOT( changedDeviceType(int) ) );
     connect( newNetworkAction, SIGNAL( activated(int) ), this, SLOT( changedNetworkAction(int) ) );
     connect( newClientAction, SIGNAL( activated(int) ), this, SLOT( changedClientAction(int) ) );
     connect( newStationAction, SIGNAL( activated(int) ), this, SLOT( changedStationAction(int) ) );
     connect( getCaptureFileName, SIGNAL( clicked() ), this, SLOT( getCaptureFileNameClicked() ) );
 
     // make the checkbox 'channelAll' control all other channels
     connect( channelAll, SIGNAL( stateChanged(int) ), this, SLOT( channelAllClicked(int) ) );
 
     connect( autodetect, SIGNAL( clicked() ), this, SLOT( performAutodetection() ) );
 
     // hide tab4 (parse) until Wellenreiter 1.2
     tab->removePage( tab_4 );
 };
 
 
 void WellenreiterConfigWindow::accept()
 {
     save();
     QDialog::accept();
 }
 
 
 WellenreiterConfigWindow::~WellenreiterConfigWindow()
 {
 }
 
 
 void WellenreiterConfigWindow::performAutodetection()
 {
     //TODO: insert modal splash screen here
     //      and sleep a second, so that it looks
     //      like we're actually doing something fancy... ;-)
 
     qDebug( "WellenreiterConfigWindow::performAutodetection()" );
 
     // try to guess device type
     QFile m( "/proc/modules" );
     if ( m.open( IO_ReadOnly ) )
     {
         int devicetype(0);
         QString line;
         QTextStream modules( &m );
         while( !modules.atEnd() && !devicetype )
         {
             modules >> line;
             if ( line.contains( "cisco" ) ) devicetype = DEVTYPE_CISCO;
             else if ( line.contains( "hostap" ) ) devicetype = DEVTYPE_HOSTAP;
             else if ( line.contains( "prism" ) ) devicetype = DEVTYPE_WLAN_NG;
             else if ( line.contains( "orinoco" ) ) devicetype = DEVTYPE_ORINOCO;
         }
         if ( devicetype )
         {
             deviceType->setCurrentItem( devicetype );
             _guess = devicetype;
             qDebug( "Wellenreiter: guessed device type to be #%d", devicetype );
         }
     }
 }
 
 
 int WellenreiterConfigWindow::driverType() const
 {
     QString name = deviceType->currentText();
     if ( _devicetype.contains( name ) )
     {
         return _devicetype[name];
     }
     else
     {
         return 0;
     }
 };
 
 
 int WellenreiterConfigWindow::hoppingInterval() const
 {
     return hopInterval->cleanText().toInt();
 }
 
 
 bool WellenreiterConfigWindow::usePrismHeader() const
 {
     return prismHeader->isChecked();
 }
 
 
 bool WellenreiterConfigWindow::isChannelChecked( int channel ) const
 {
     switch ( channel )
     {
         case 1: return channel1->isOn();
         case 2: return channel2->isOn();
         case 3: return channel3->isOn();
         case 4: return channel4->isOn();
         case 5: return channel5->isOn();
         case 6: return channel6->isOn();
         case 7: return channel7->isOn();
         case 8: return channel8->isOn();
         case 9: return channel9->isOn();
         case 10: return channel10->isOn();
         case 11: return channel11->isOn();
         case 12: return channel12->isOn();
         case 13: return channel13->isOn();
         case 14: return channel14->isOn();
     }
 }
 
 
 void WellenreiterConfigWindow::changedDeviceType(int t)
 {
     if ( t != DEVTYPE_FILE ) return;
     QString name = ( (WellenreiterMainWindow*) qApp->mainWidget() )->getFileName(false);
     if ( !name.isEmpty() && QFile::exists( name ) )
     {
         interfaceName->insertItem( name );
         interfaceName->setCurrentItem( interfaceName->count()-1 );
     }
     else
     {
         deviceType->setCurrentItem( _guess );
     }
 
 }
 
 
 void WellenreiterConfigWindow::synchronizeActionsAndScripts()
 {
     if ( newNetworkAction->currentItem() == 4 ) newNetworkScript->show(); else newNetworkScript->hide();
     if ( newClientAction->currentItem() == 4 ) newClientScript->show(); else newClientScript->hide();
     if ( newStationAction->currentItem() == 4 ) newStationScript->show(); else newStationScript->hide();
 
     //newNetworkScript->setEnabled( newNetworkAction->currentItem() == 4 );
     //newClientScript->setEnabled( newClientAction->currentItem() == 4 );
     //newStationScript->setEnabled( newStationAction->currentItem() == 4 );
 }
 
 
 void WellenreiterConfigWindow::changedNetworkAction(int t)
 {
     synchronizeActionsAndScripts();
 }
 
 
 void WellenreiterConfigWindow::changedClientAction(int t)
 {
     synchronizeActionsAndScripts();
 }
 
 
 void WellenreiterConfigWindow::changedStationAction(int t)
 {
     synchronizeActionsAndScripts();
 }
 
 
 void WellenreiterConfigWindow::getCaptureFileNameClicked()
 {
     QString name = ( (WellenreiterMainWindow*) qApp->mainWidget() )->getFileName(true);
diff --git a/noncore/net/wellenreiter/gui/main.cpp b/noncore/net/wellenreiter/gui/main.cpp
index 7dcc583..6bbc39b 100644
--- a/noncore/net/wellenreiter/gui/main.cpp
+++ b/noncore/net/wellenreiter/gui/main.cpp
@@ -1,110 +1,113 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "mainwindow.h"
 #ifdef QWS
 #include <opie2/oapplication.h>
 #include <opie2/oprocess.h>
 #else
 #include <qapplication.h>
 #endif
 
 #include <qmessagebox.h>
 #include <qstringlist.h>
 
 #include <errno.h>
 #include <signal.h>
 #include <string.h>
 #include <unistd.h>
 
+using namespace Opie::Core;
+using namespace Opie::Core;
+using namespace Opie::Core;
 int main( int argc, char **argv )
 {
     #ifdef QWS
     OApplication a( argc, argv, "Wellenreiter II" );
     #else
     QApplication a( argc, argv );
     #endif
     WellenreiterMainWindow* w = new WellenreiterMainWindow();
     #ifdef QWS
     a.showMainWidget( w );
     #else
     a.setMainWidget( w );
     w->setCaption( "Wellenreiter II" );
     w->show();
     #endif
 
     a.processEvents(); // show the window before doing the safety checks
     int result = -1;
     static int killed = false;
 
     bool check = true;
     for ( int i = 1; i < argc; ++i )
     {
         qDebug( "Wellenreiter::main() parsing argument %d = '%s'", i, argv[i] );
         if ( !strcmp( "-nocheck", argv[i] ) )
         {
             qDebug( "-nocheck found" );
             check = false;
             break;
         }
     }
 
     if ( check )
     {
         // root check
         if ( getuid() )
         {
             qWarning( QObject::tr( "Wellenreiter: trying to run as non-root!" ) );
             result = QMessageBox::warning( w, " - Wellenreiter II -  (non-root)", QObject::tr( "You have started Wellenreiter II\n"
             "as non-root. You will have\nonly limited functionality.\nProceed anyway?" ),
             QMessageBox::Yes, QMessageBox::No );
             if ( result == QMessageBox::No ) return -1;
         }
 
         int dhcpid = OProcess::processPID( "dhcpc" );
 
         if ( dhcpid )
         {
             result = QMessageBox::warning( w, " - Wellenreiter II -  (dhcp)", QObject::tr( "You have a dhcp client running.\n"
             "(PID = %1)\nThis can severly limit scanning!\nShould I kill it for you?" ).arg( dhcpid ),
             QMessageBox::Yes, QMessageBox::No );
             if ( result == QMessageBox::Yes )
             {
                 if ( -1 == ::kill( dhcpid, SIGTERM ) )
                     qWarning( "Wellenreiter: can't kill process #%d (%s)", result, strerror( errno ) );
                 else
                     killed = true;
             }
         }
     }
 
     a.exec();
 
     if ( check )
     {
 
         if ( killed )
         {
             result = QMessageBox::warning( w, " - Wellenreiter II -  (dhcp)", QObject::tr( "Restart your dhcp client?" ), QMessageBox::Yes, QMessageBox::No );
             if ( result == QMessageBox::Yes )
             {
                 ::system( QString().sprintf( "dhclient &; udhcpcd &; dhcpcd &" ) );
             }
         }
 
         delete w;
     }
     return 0;
 }
diff --git a/noncore/net/wellenreiter/gui/mainwindow.cpp b/noncore/net/wellenreiter/gui/mainwindow.cpp
index 5cc0daf..7add6cd 100644
--- a/noncore/net/wellenreiter/gui/mainwindow.cpp
+++ b/noncore/net/wellenreiter/gui/mainwindow.cpp
@@ -1,245 +1,250 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "configwindow.h"
 #include "gps.h"
 #include "logwindow.h"
 #include "packetview.h"
 #include "mainwindow.h"
 #include "wellenreiter.h"
 #include "scanlist.h"
 
 #include <qcombobox.h>
 #include <qdatastream.h>
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qiconset.h>
 #include <qmenubar.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qstatusbar.h>
 #include <qspinbox.h>
 #include <qtextstream.h>
 #include <qtoolbutton.h>
 #include <qwhatsthis.h>
 
 #ifdef QWS
 #include <qpe/resource.h>
 #include <opie2/ofiledialog.h>
 using namespace Opie;
 #else
 #include "resource.h"
 #include <qapplication.h>
 #include <qfiledialog.h>
 #endif
 
 #include <unistd.h>
 
+using namespace Opie::Ui;
+using namespace Opie::Net;
+using namespace Opie::Ui;
+using namespace Opie::Net;
+using namespace Opie::Net;
 WellenreiterMainWindow::WellenreiterMainWindow( QWidget * parent, const char * name, WFlags f )
            :QMainWindow( parent, name, f )
 {
     cw = new WellenreiterConfigWindow( this );
     mw = new Wellenreiter( this );
     mw->setConfigWindow( cw );
     setCentralWidget( mw );
 
     // setup application icon
 
     setIcon( Resource::loadPixmap( "wellenreiter/appicon-trans" ) );
     #ifndef QWS
     setIconText( "Wellenreiter/X11" );
     #endif
 
     // setup tool buttons
 
     startButton = new QToolButton( 0 );
     QWhatsThis::add( startButton, tr( "Click here to start scanning." ) );
     #ifdef QWS
     startButton->setAutoRaise( true );
     #endif
     startButton->setIconSet( Resource::loadIconSet( "wellenreiter/SearchIcon" ) );
     startButton->setEnabled( false );
     connect( startButton, SIGNAL( clicked() ), mw, SLOT( startClicked() ) );
 
     stopButton = new QToolButton( 0 );
     QWhatsThis::add( stopButton, tr( "Click here to stop scanning." ) );
     #ifdef QWS
     stopButton->setAutoRaise( true );
     #endif
     stopButton->setIconSet( Resource::loadIconSet( "wellenreiter/CancelIcon" ) );
     stopButton->setEnabled( false );
     connect( stopButton, SIGNAL( clicked() ), mw, SLOT( stopClicked() ) );
 
     QToolButton* d = new QToolButton( 0 );
     QWhatsThis::add( d, tr( "Click here to open the configure dialog." ) ),
     #ifdef QWS
     d->setAutoRaise( true );
     #endif
     d->setIconSet( Resource::loadIconSet( "wellenreiter/SettingsIcon" ) );
     connect( d, SIGNAL( clicked() ), this, SLOT( showConfigure() ) );
 
     uploadButton = new QToolButton( 0 );
     QWhatsThis::add( uploadButton, tr( "Click here to upload a capture session." ) );
     #ifdef QWS
     uploadButton->setAutoRaise( true );
     #endif
     uploadButton->setIconSet( Resource::loadIconSet( "up" ) );
     uploadButton->setEnabled( false );
     //uploadButton->setEnabled( true ); // DEBUGGING
     connect( uploadButton, SIGNAL( clicked() ), this, SLOT( uploadSession() ) );
 
     // setup menu bar
 
     int id;
 
     QMenuBar* mb = menuBar();
 
     QPopupMenu* fileSave = new QPopupMenu( mb );
     fileSave->insertItem( tr( "&Session..." ), this, SLOT( fileSaveSession() ) );
     fileSave->insertItem( tr( "&Text Log..." ), this, SLOT( fileSaveLog() ) );
     fileSave->insertItem( tr( "&Hex Log..." ), this, SLOT( fileSaveHex() ) );
 
     QPopupMenu* fileLoad = new QPopupMenu( mb );
     fileLoad->insertItem( tr( "&Session..." ), this, SLOT( fileLoadSession() ) );
     //fileLoad->insertItem( "&Log", this, SLOT( fileLoadLog() ) );
 
     QPopupMenu* file = new QPopupMenu( mb );
     file->insertItem( tr( "&New" ), this, SLOT( fileNew() ) );
     id = file->insertItem( tr( "&Load" ), fileLoad );
     file->insertItem( tr( "&Save" ), fileSave );
     file->insertSeparator();
     uploadID = file->insertItem( tr( "&Upload Session" ), this, SLOT( uploadSession() ) );
     file->insertSeparator();
     file->insertItem( tr( "&Exit" ), qApp, SLOT( quit() ) );
 
     QPopupMenu* sniffer = new QPopupMenu( mb );
     sniffer->insertItem( tr( "&Configure..." ), this, SLOT( showConfigure() ) );
     sniffer->insertSeparator();
     startID = sniffer->insertItem( tr( "&Start" ), mw, SLOT( startClicked() ) );
     sniffer->setItemEnabled( startID, false );
     stopID = sniffer->insertItem( tr( "Sto&p" ), mw, SLOT( stopClicked() ) );
     sniffer->setItemEnabled( stopID, false );
 
     QPopupMenu* view = new QPopupMenu( mb );
     view->insertItem( tr( "&Expand All" ), this, SLOT( viewExpandAll() ) );
     view->insertItem( tr( "&Collapse All" ), this, SLOT( viewCollapseAll() ) );
 
     QPopupMenu* demo = new QPopupMenu( mb );
     demo->insertItem( tr( "&Add something" ), this, SLOT( demoAddStations() ) );
     //demo->insertItem( tr( "&Read from GPSd" ), this, SLOT( demoReadFromGps() ) );
 
     id = mb->insertItem( tr( "&File" ), file );
 
     id = mb->insertItem( tr( "&View" ), view );
     //mb->setItemEnabled( id, false );
 
     id = mb->insertItem( tr( "&Sniffer" ), sniffer );
 
     id = mb->insertItem( tr( "&Demo" ), demo );
     mb->setItemEnabled( id, true );
     mb->setItemEnabled( uploadID, false );
 
     #ifdef QWS
     mb->insertItem( startButton );
     mb->insertItem( stopButton );
     mb->insertItem( uploadButton );
     mb->insertItem( d );
     #else // Qt3 changed the insertion order. It's now totally random :(
     mb->insertItem( d );
     mb->insertItem( uploadButton );
     mb->insertItem( stopButton );
     mb->insertItem( startButton );
     #endif
 
     updateToolButtonState();
 
     // setup status bar (for now only on X11)
 
     #ifndef QWS
     statusBar()->message( tr( "Ready." ) );
     #endif
 
     connect( mw, SIGNAL( startedSniffing() ), this, SLOT( changedSniffingState() ) );
     connect( mw, SIGNAL( stoppedSniffing() ), this, SLOT( changedSniffingState() ) );
 };
 
 
 
 void WellenreiterMainWindow::showConfigure()
 {
     qDebug( "show configure..." );
     cw->setCaption( tr( "Configure" ) );
     int result = QPEApplication::execDialog( cw );
 
     if ( result ) updateToolButtonState();
 }
 
 
 void WellenreiterMainWindow::updateToolButtonState()
 {
     const QString& interface = cw->interfaceName->currentText();
     const int cardtype = cw->driverType();
 
     if ( ( interface != "<select>" ) && ( cardtype != 0 ) )
     {
         startButton->setEnabled( true );
         menuBar()->setItemEnabled( startID, true );
     }
     else
     {
         startButton->setEnabled( false );
         menuBar()->setItemEnabled( startID, false );
     }
 }
 
 
 void WellenreiterMainWindow::changedSniffingState()
 {
     startButton->setEnabled( !mw->sniffing );
     menuBar()->setItemEnabled( startID, !mw->sniffing );
     stopButton->setEnabled( mw->sniffing );
     menuBar()->setItemEnabled( stopID, mw->sniffing );
 
     if ( !mw->sniffing )
     {
         menuBar()->setItemEnabled( uploadID, true );
         uploadButton->setEnabled( true );
     }
 }
 
 
 WellenreiterMainWindow::~WellenreiterMainWindow()
 {
     qDebug( "Wellenreiter: bye." );
 };
 
 
 void WellenreiterMainWindow::demoAddStations()
 {
     //mw = 0; // test SIGSEGV handling
 
     mw->netView()->addNewItem( "managed", "Vanille", OMacAddress::fromString("00:00:20:EF:A6:43"), true, 6, 80, GpsLocation( 39.8794, -94.0936) );
     mw->netView()->addNewItem( "managed", "Vanille", OMacAddress::fromString("00:30:6D:EF:A6:23"), true, 11, 10, GpsLocation( 0.0, 0.0 ) );
     mw->netView()->addNewItem( "adhoc", "ELAN", OMacAddress::fromString("00:03:F8:E7:16:22"), false, 3, 10, GpsLocation( 5.5, 2.3 ) );
     mw->netView()->addNewItem( "adhoc", "ELAN", OMacAddress::fromString("00:04:01:E7:56:62"), false, 3, 15, GpsLocation( 2.3, 5.5 ) );
     mw->netView()->addNewItem( "adhoc", "ELAN", OMacAddress::fromString("00:05:8E:E7:56:E2"), false, 3, 20, GpsLocation( -10.0, -20.5 ) );
 }
 
 
 void WellenreiterMainWindow::demoReadFromGps()
diff --git a/noncore/net/wellenreiter/gui/packetview.cpp b/noncore/net/wellenreiter/gui/packetview.cpp
index ef5d020..8312e71 100644
--- a/noncore/net/wellenreiter/gui/packetview.cpp
+++ b/noncore/net/wellenreiter/gui/packetview.cpp
@@ -1,68 +1,71 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "packetview.h"
 
 /* OPIE */
 #include <opie2/opcap.h>
 
 /* QT */
 #include <qtextview.h>
 #include <qspinbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlist.h>
 
+using namespace Opie::Net;
+using namespace Opie::Net;
+using namespace Opie::Net;
 PacketView::PacketView( QWidget * parent, const char * name, WFlags f )
            :QFrame( parent, name, f )
 {
     _number = new QSpinBox( this );
     _number->setPrefix( "Packet # " );
     _label = new QLabel( this );
     _label->setText( "eth0 2004/03/08 - 00:00:21" );
     _list = new QLabel( this );
     _hex = new QTextView( this );
 
     QVBoxLayout* vb = new QVBoxLayout( this, 2, 2 );
     QHBoxLayout* hb = new QHBoxLayout( vb, 2 );
     hb->addWidget( _label );
     hb->addWidget( _number );
     vb->addWidget( _list );
     vb->addWidget( _hex );
 
     _packets.setAutoDelete( true );
 
     _list->setText( "<b>[ 802.11 [ LLC [ IP [ UDP [ DHCP ] ] ] ] ]</b>" );
 };
 
 void PacketView::add( OPacket* p )
 {
     _packets.append( p );
 };
 
 const QString PacketView::getLog() const
 {
 }
 
 void PacketView::clear()
 {
     _packets.clear();
     _number->setMinValue( 0 );
     _number->setMaxValue( 0 );
     _label->setText( "---" );
     _list->setText( " <b>-- no Packet available --</b> " );
     _hex->setText( " <i>-- no Packet available --</i> " );
 }
 
diff --git a/noncore/net/wellenreiter/gui/packetview.h b/noncore/net/wellenreiter/gui/packetview.h
index b5f2b26..1ac19bb 100644
--- a/noncore/net/wellenreiter/gui/packetview.h
+++ b/noncore/net/wellenreiter/gui/packetview.h
@@ -1,49 +1,49 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef PACKETVIEW_H
 #define PACKETVIEW_H
 
 #include <qlist.h>
 #include <qframe.h>
 
 class QString;
 class QSpinBox;
 class QLabel;
 class QTextView;
-class OPacket;
+namespace Opie {namespace Net {class Opie::Net::OPacket;}}
 
 class PacketView: public QFrame
 {
 
   public:
     PacketView( QWidget * parent = 0, const char * name = "PacketView", WFlags f = 0 );
 
-    void add( OPacket* p );
+    void add( Opie::Net::OPacket* p );
     const QString getLog() const;
     void clear();
 
   protected:
 
     QSpinBox* _number;
     QLabel* _label;
     QLabel* _list;
     QTextView* _hex;
-    QList<OPacket> _packets;
+    QList<Opie::Net::OPacket> _packets;
 
 };
 
 #endif
 
diff --git a/noncore/net/wellenreiter/gui/scanlist.cpp b/noncore/net/wellenreiter/gui/scanlist.cpp
index 6005818..3b7120a 100644
--- a/noncore/net/wellenreiter/gui/scanlist.cpp
+++ b/noncore/net/wellenreiter/gui/scanlist.cpp
@@ -1,240 +1,246 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "scanlist.h"
 #include "configwindow.h"
 #include "logwindow.h"
 
 #include <assert.h>
 #include <qcursor.h>
 #include <qdatetime.h>
 #include <qpopupmenu.h>
 #include <qcheckbox.h>
 
 #ifdef QWS
 #include <qpe/qpeapplication.h>
 #endif
 
 #ifdef QWS
 #include <qpe/resource.h>
 #else
 #include "resource.h"
 #endif
 
 const int col_type = 0;
 const int col_essid = 0;
 const int col_sig = 1;
 const int col_ap = 2;
 const int col_channel = 3;
 const int col_wep = 4;
 const int col_traffic = 5;
 const int col_ip = 6;
 const int col_manuf = 7;
 const int col_firstseen = 8;
 const int col_lastseen = 9;
 const int col_location = 10;
 
+using namespace Opie::Net;
+using namespace Opie::Ui;
+using namespace Opie::Net;
+using namespace Opie::Ui;
+using namespace Opie::Ui;
+using namespace Opie::Net;
 MScanListView::MScanListView( QWidget* parent, const char* name )
               :OListView( parent, name )
 {
     setFrameShape( QListView::StyledPanel );
     setFrameShadow( QListView::Sunken );
 
     addColumn( tr( "Net/Station" ) );
     setColumnAlignment( col_essid, AlignLeft || AlignVCenter );
     addColumn( tr( "#" ) );
     setColumnAlignment( col_sig, AlignCenter );
     addColumn( tr( "MAC" ) );
     setColumnAlignment( col_ap, AlignCenter );
     addColumn( tr( "Chn" ) );
     setColumnAlignment( col_channel, AlignCenter );
     addColumn( tr( "W" ) );
     setColumnAlignment( col_wep, AlignCenter );
     addColumn( tr( "T" ) );
     setColumnAlignment( col_traffic, AlignCenter );
     addColumn( tr( "IP" ) );
     setColumnAlignment( col_ip, AlignCenter );
     addColumn( tr( "Manufacturer" ) );
     setColumnAlignment( col_manuf, AlignCenter );
     addColumn( tr( "First Seen" ) );
     setColumnAlignment( col_firstseen, AlignCenter );
     addColumn( tr( "Last Seen" ) );
     setColumnAlignment( col_lastseen, AlignCenter );
     addColumn( tr( "Location" ) );
     setColumnAlignment( col_location, AlignCenter );
     setRootIsDecorated( true );
     setAllColumnsShowFocus( true );
 
     connect( this, SIGNAL( rightButtonClicked(QListViewItem*,const QPoint&,int) ),
              this, SLOT( contextMenuRequested(QListViewItem*,const QPoint&,int) ) );
 
     #ifdef QWS
     QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
     #endif
 
 };
 
 
 MScanListView::~MScanListView()
 {
 };
 
 
 OListViewItem* MScanListView::childFactory()
 {
     return new MScanListItem( this );
 }
 
 
 void MScanListView::serializeTo( QDataStream& s) const
 {
     qDebug( "serializing MScanListView" );
     OListView::serializeTo( s );
 }
 
 
 void MScanListView::serializeFrom( QDataStream& s)
 {
     qDebug( "serializing MScanListView" );
     OListView::serializeFrom( s );
 }
 
 
 void MScanListView::addNewItem( const QString& type,
                                 const QString& essid,
                                 const OMacAddress& mac,
                                 bool wep,
                                 int channel,
                                 int signal,
                                 const GpsLocation& loc,
                                 bool probe )
 {
     QString macaddr = mac.toString(true);
 
     #ifdef DEBUG
     qDebug( "MScanList::addNewItem( %s / %s / %s [%d]", (const char*) type,
             (const char*) essid, (const char*) macaddr, channel );
     #endif
 
     // search, if we already have seen this net
 
     QString s;
     MScanListItem* network;
     MScanListItem* item = static_cast<MScanListItem*> ( firstChild() );
 
     while ( item && ( item->text( col_essid ) != essid ) )
     {
         #ifdef DEBUG
         qDebug( "itemtext: %s", (const char*) item->text( col_essid ) );
         #endif
         item = static_cast<MScanListItem*> ( item->nextSibling() );
     }
     if ( item )
     {
         // we have already seen this net, check all childs if MAC exists
 
         network = item;
 
         item = static_cast<MScanListItem*> ( item->firstChild() );
         assert( item ); // this shouldn't fail
 
         while ( item && ( item->text( col_ap ) != macaddr ) )
         {
             #ifdef DEBUG
             qDebug( "subitemtext: %s", (const char*) item->text( col_ap ) );
             #endif
             item = static_cast<MScanListItem*> ( item->nextSibling() );
         }
 
         if ( item )
         {
             // we have already seen this item, it's a dupe
             #ifdef DEBUG
             qDebug( "%s is a dupe - ignoring...", (const char*) macaddr );
             #endif
             item->receivedBeacon();
             return;
         }
     }
     else
     {
         s.sprintf( "(i) New network: ESSID '%s'", (const char*) essid );
         MLogWindow::logwindow()->log( s );
         network = new MScanListItem( this, "network", essid, QString::null, 0, 0, 0, probe );
     }
 
 
     // insert new station as child from network
     // no essid to reduce clutter, maybe later we have a nick or stationname to display!?
 
     #ifdef DEBUG
     qDebug( "inserting new station %s", (const char*) macaddr );
     #endif
 
     MScanListItem* station = new MScanListItem( network, type, "", macaddr, wep, channel, signal );
     station->setManufacturer( mac.manufacturer() );
     station->setLocation( loc.dmsPosition() );
 
     if ( type == "managed" )
     {
         s.sprintf( "(i) New Access Point in '%s' [%d]", (const char*) essid, channel );
     }
     else
     {
         s.sprintf( "(i) New AdHoc station in '%s' [%d]", (const char*) essid, channel );
     }
     MLogWindow::logwindow()->log( s );
 }
 
 
 void MScanListView::addIfNotExisting( MScanListItem* network, const OMacAddress& addr, const QString& type )
 {
     MScanListItem* subitem = static_cast<MScanListItem*>( network->firstChild() );
 
     while ( subitem && ( subitem->text( col_ap ) != addr.toString(true) ) )
     {
         #ifdef DEBUG
         qDebug( "subitemtext: %s", (const char*) subitem->text( col_ap ) );
         #endif
         subitem = static_cast<MScanListItem*> ( subitem->nextSibling() );
     }
 
     if ( subitem )
     {
         // we have already seen this item, it's a dupe
         #ifdef DEBUG
         qDebug( "%s is a dupe - ignoring...", (const char*) addr.toString(true) );
         #endif
         subitem->receivedBeacon(); //FIXME: sent data bit
         return;
     }
 
     // Hey, it seems to be a new item :-D
     MScanListItem* station = new MScanListItem( network, type, /* network->text( col_essid ) */ "", addr.toString(true), false, -1, -1 );
     station->setManufacturer( addr.manufacturer() );
 
     QString s;
     if ( type == "station" )
     {
         s.sprintf( "(i) New Station in '%s' [xx]", (const char*) network->text( col_essid ) );
     }
     else
     {
         s.sprintf( "(i) New Wireless Station in '%s' [xx]", (const char*) network->text( col_essid ) );
     }
     MLogWindow::logwindow()->log( s );
 }
 
 
diff --git a/noncore/net/wellenreiter/gui/scanlist.h b/noncore/net/wellenreiter/gui/scanlist.h
index ab870c2..6a80f70 100644
--- a/noncore/net/wellenreiter/gui/scanlist.h
+++ b/noncore/net/wellenreiter/gui/scanlist.h
@@ -1,140 +1,140 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef SCANLIST_H
 #define SCANLIST_H
 
 #include "gps.h"
 
 /* OPIE */
 #include <opie2/olistview.h>
 #include <opie2/onetutils.h>
 
 /* QT */
 #include <qtextstream.h>
 
 class QString;
 class MScanListItem;
 
-class MScanListView: public OListView
+class MScanListView: public Opie::Ui::OListView
 {
   Q_OBJECT
 
   public:
     MScanListView( QWidget* parent = 0, const char* name = 0 );
     virtual ~MScanListView();
 
-    virtual OListViewItem* childFactory();
+    virtual Opie::Ui::OListViewItem* childFactory();
     virtual void serializeTo( QDataStream& s ) const;
     virtual void serializeFrom( QDataStream& s );
 
   public slots:
-    void addNewItem( const QString& type, const QString&, const OMacAddress&, bool, int, int, const GpsLocation&, bool = false );
-    void addService( const QString& name, const OMacAddress& macaddr, const QString& ip );
+    void addNewItem( const QString& type, const QString&, const Opie::Net::OMacAddress&, bool, int, int, const GpsLocation&, bool = false );
+    void addService( const QString& name, const Opie::Net::OMacAddress& macaddr, const QString& ip );
 
-    void fromDStraffic( const OMacAddress& from, const OMacAddress& to, const OMacAddress& via );
-    void toDStraffic( const OMacAddress& from, const OMacAddress& to, const OMacAddress& via );
-    void WDStraffic( const OMacAddress& from, const OMacAddress& to, const OMacAddress& viaFrom, const OMacAddress& viaTo );
-    void IBSStraffic( const OMacAddress& from, const OMacAddress& to, const OMacAddress& via );
+    void fromDStraffic( const Opie::Net::OMacAddress& from, const Opie::Net::OMacAddress& to, const Opie::Net::OMacAddress& via );
+    void toDStraffic( const Opie::Net::OMacAddress& from, const Opie::Net::OMacAddress& to, const Opie::Net::OMacAddress& via );
+    void WDStraffic( const Opie::Net::OMacAddress& from, const Opie::Net::OMacAddress& to, const Opie::Net::OMacAddress& viaFrom, const Opie::Net::OMacAddress& viaTo );
+    void IBSStraffic( const Opie::Net::OMacAddress& from, const Opie::Net::OMacAddress& to, const Opie::Net::OMacAddress& via );
 
-    void identify( const OMacAddress&, const QString& ipaddr );
+    void identify( const Opie::Net::OMacAddress&, const QString& ipaddr );
 
     void contextMenuRequested( QListViewItem* item, const QPoint&, int );
 
   signals:
     void rightButtonClicked(QListViewItem*,const QPoint&,int);
     void joinNetwork( const QString&, const QString&, int, const QString& );
 
   protected:
-    void addIfNotExisting( MScanListItem* parent, const OMacAddress& addr, const QString& type = "station" );
+    void addIfNotExisting( MScanListItem* parent, const Opie::Net::OMacAddress& addr, const QString& type = "station" );
 
 };
 
 //****************************** MScanListItem ****************************************************************
 
-class MScanListItem: public OListViewItem
+class MScanListItem: public Opie::Ui::OListViewItem
 {
   public:
     MScanListItem::MScanListItem( QListView* parent,
                                   const QString& type = "unknown",
                                   const QString& essid = "unknown",
                                   const QString& macaddr = "unknown",
                                   bool wep = false,
                                   int channel = 0,
                                   int signal = 0,
                                   bool probed = false );
 
     MScanListItem::MScanListItem( QListViewItem* parent,
                                   const QString& type = "unknown",
                                   const QString& essid = "unknown",
                                   const QString& macaddr = "unknown",
                                   bool wep = false,
                                   int channel = 0,
                                   int signal = 0 );
 
 
   protected:
     virtual void decorateItem( QString type, QString essid, QString macaddr, bool wep, int channel, int signal, bool probed );
 
   public:
     QString type;
 
   public:
     //const QString& type() { return _type; };
     const QString& essid() const;
     const QString& macaddr() { return _macaddr; };
     bool wep() { return _wep; };
     int channel() { return _channel; };
     int signal() { return _signal; };
     int beacons() { return _beacons; };
 
     void setSignal( int signal ) { /* TODO */ };
     void receivedBeacon();
 
     void setManufacturer( const QString& manufacturer );
     void setLocation( const QString& location );
 
-    virtual OListViewItem* childFactory();
+    virtual Opie::Ui::OListViewItem* childFactory();
     virtual void serializeTo( QDataStream& s ) const;
     virtual void serializeFrom( QDataStream& s );
 
   private:
     QString _type;
     QString _essid;
     QString _macaddr;
     bool _wep;
     int _channel;
     int _signal;
     int _beacons;
 
 };
 
 //****************************** MScanListViewFactory ****************************************************************
 
 /*
 
-class MScanListViewFactory : public OListViewFactory
+class MScanListViewFactory : public Opie::Ui::OListViewFactory
 {
 public:
     virtual QListView* listViewFactory();
     virtual QListViewItem* listViewItemFactory( QListView* lv );
     virtual QListViewItem* listViewItemFactory( QListViewItem* lvi );
     virtual void setColumnText( int depth, QListViewItem* lvi, int column, const QString& text );
     virtual void setCustomData( int depth, QListViewItem* lvi, const QString& text );
 }
 */
 
 #endif
 
diff --git a/noncore/net/wellenreiter/gui/statwindow.cpp b/noncore/net/wellenreiter/gui/statwindow.cpp
index 48e4847..e3c6bbe 100644
--- a/noncore/net/wellenreiter/gui/statwindow.cpp
+++ b/noncore/net/wellenreiter/gui/statwindow.cpp
@@ -1,43 +1,46 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "statwindow.h"
 #include <opie2/olistview.h>
 
+using namespace Opie::Ui;
+using namespace Opie::Ui;
+using namespace Opie::Ui;
 MStatWindow::MStatWindow( QWidget * parent, const char * name, WFlags f )
            :QVBox( parent, name, f )
 {
     table = new OListView( this );
     table->addColumn( tr( "Protocol" ) );
     table->addColumn( tr( "Count" ) );
     table->setItemMargin( 2 );
 };
 
 
 void MStatWindow::updateCounter( const QString& protocol, int counter )
 {
     QListViewItemIterator it( table );
     for ( ; it.current(); ++it )
     {
         if ( it.current()->text( 0 ) == protocol )
         {
             it.current()->setText( 1, QString::number( counter ) );
             return;
         }
     }
 
     new OListViewItem( table, protocol, QString::number( counter ) );
 }
 
diff --git a/noncore/net/wellenreiter/gui/statwindow.h b/noncore/net/wellenreiter/gui/statwindow.h
index b9057e7..e11247b 100644
--- a/noncore/net/wellenreiter/gui/statwindow.h
+++ b/noncore/net/wellenreiter/gui/statwindow.h
@@ -1,43 +1,43 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef STATWINDOW_H
 #define STATWINDOW_H
 
 #include <qvbox.h>
 
 class QString;
-class OListView;
+namespace Opie {namespace Ui {class Opie::Ui::OListView;}}
 
 class MStatWindow: public QVBox
 {
   Q_OBJECT
 
   public:
     MStatWindow( QWidget * parent = 0, const char * name = "MStatWindow", WFlags f = 0 );
 
     void log( QString text );
     const QString getLog() const;
     void clear();
 
     void updateCounter( const QString&, int );
 
   protected:
-    OListView* table;
+    Opie::Ui::OListView* table;
 
 };
 
 #endif
 
diff --git a/noncore/net/wellenreiter/gui/wellenreiter.cpp b/noncore/net/wellenreiter/gui/wellenreiter.cpp
index ce416e5..e8d9de7 100644
--- a/noncore/net/wellenreiter/gui/wellenreiter.cpp
+++ b/noncore/net/wellenreiter/gui/wellenreiter.cpp
@@ -1,255 +1,261 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ***********************************************************************/
 
 // Local
 
 #include "gps.h"
 #include "wellenreiter.h"
 #include "scanlist.h"
 #include "logwindow.h"
 #include "packetview.h"
 #include "configwindow.h"
 #include "statwindow.h"
 #include "graphwindow.h"
 #include "protolistview.h"
 
 // Opie
 
 #ifdef QWS
 #include <opie2/oapplication.h>
 #include <opie2/odevice.h>
 #else
 #include <qapplication.h>
 #endif
 #include <opie2/omanufacturerdb.h>
 #include <opie2/onetwork.h>
 #include <opie2/opcap.h>
 #include <qpe/qcopenvelope_qws.h>
 using namespace Opie;
 
 // Qt
 
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qdatetime.h>
 #include <qpushbutton.h>
 #include <qlineedit.h>
 #include <qmessagebox.h>
 #include <qobjectlist.h>
 #include <qregexp.h>
 #include <qspinbox.h>
 #include <qtimer.h>
 #include <qtoolbutton.h>
 #include <qmainwindow.h>
 
 // Standard
 
 #include <assert.h>
 #include <errno.h>
 #include <unistd.h>
 #include <string.h>
 #include <sys/types.h>
 #include <stdlib.h>
 
+using namespace Opie::Core;
+using namespace Opie::Net;
+using namespace Opie::Net;
+using namespace Opie::Core;
+using namespace Opie::Net;
+using namespace Opie::Core;
 Wellenreiter::Wellenreiter( QWidget* parent )
     : WellenreiterBase( parent, 0, 0 ),
       sniffing( false ), iface( 0 ), configwindow( 0 )
 {
 
     logwindow->log( "(i) Wellenreiter has been started." );
 
     //
     // detect operating system
     //
 
     #ifdef QWS
     QString sys;
     sys.sprintf( "(i) Running on '%s'.", (const char*) ODevice::inst()->systemString() );
     _system = ODevice::inst()->system();
     logwindow->log( sys );
     #endif
 
     netview->setColumnWidthMode( 1, QListView::Manual );
     connect( netview, SIGNAL( joinNetwork(const QString&,const QString&,int,const QString&) ),
              this, SLOT( joinNetwork(const QString&,const QString&,int,const QString&) ) );
     pcap = new OPacketCapturer();
 
     gps = new GPS( this );
 
     QTimer::singleShot( 1000, this, SLOT( initialTimer() ) );
 
 }
 
 
 Wellenreiter::~Wellenreiter()
 {
     delete pcap;
 }
 
 
 void Wellenreiter::initialTimer()
 {
     qDebug( "Wellenreiter::preloading manufacturer database..." );
     OManufacturerDB::instance();
 }
 
 
 void Wellenreiter::setConfigWindow( WellenreiterConfigWindow* cw )
 {
     configwindow = cw;
 }
 
 
 void Wellenreiter::channelHopped(int c)
 {
     QString title = "Wellenreiter II -scan- [";
     QString left;
     if ( c > 1 ) left.fill( '.', c-1 );
     title.append( left );
     title.append( '|' );
     if ( c < iface->channels() )
     {
         QString right;
         right.fill( '.', iface->channels()-c );
         title.append( right );
     }
     title.append( "]" );
     //title.append( QString().sprintf( " %02d", c ) );
     assert( parent() );
     ( (QMainWindow*) parent() )->setCaption( title );
 }
 
 
 void Wellenreiter::handleNotification( OPacket* p )
 {
     QObjectList* l = p->queryList();
     QObjectListIt it( *l );
     QObject* o;
 
     while ( (o = it.current()) != 0 )
     {
         QString name = it.current()->name();
         if ( configwindow->parsePackets->isProtocolChecked( name ) )
         {
             QString action = configwindow->parsePackets->protocolAction( name );
             qDebug( "parsePacket-action for '%s' seems to be '%s'", (const char*) name, (const char*) action );
             doAction( action, name, p );
         }
         else
         {
             qDebug( "protocol '%s' not checked in parsePackets.", (const char*) name );
         }
     ++it;
     }
 }
 
 
 void Wellenreiter::handleManagementFrame( OPacket* p, OWaveLanManagementPacket* manage )
 {
     if ( manage->managementType() == "Beacon" ) handleManagementFrameBeacon( p, manage );
     else if ( manage->managementType() == "ProbeRequest" ) handleManagementFrameProbeRequest( p, manage );
     else if ( manage->managementType() == "ProbeResponse" ) handleManagementFrameProbeResponse( p, manage );
     else qWarning( "Wellenreiter::handleManagementFrame(): '%s' - please handle me!", (const char*) manage->managementType() );
 }
 
 
 void Wellenreiter::handleManagementFrameProbeRequest( OPacket* p, OWaveLanManagementPacket* request )
 {
     OWaveLanManagementSSID* ssid = static_cast<OWaveLanManagementSSID*>( p->child( "802.11 SSID" ) );
     QString essid = ssid ? ssid->ID( true /* decloak */ ) : QString("<unknown>");
     OWaveLanManagementDS* ds = static_cast<OWaveLanManagementDS*>( p->child( "802.11 DS" ) );
     int channel = ds ? ds->channel() : -1;
     OWaveLanPacket* header = static_cast<OWaveLanPacket*>( p->child( "802.11" ) );
 
     GpsLocation loc( -111, -111 );
     if ( configwindow->enableGPS->isChecked() )
     {
         // TODO: add check if GPS is working!?
         qDebug( "Wellenreiter::gathering GPS data..." );
         loc = gps->position();
         qDebug( "Wellenreiter::GPS data received is ( %f , %f ) - dms string = '%s'", loc.latitude(), loc.longitude(), loc.dmsPosition().latin1() );
     }
 
     if ( essid.length() )
         netView()->addNewItem( "adhoc", essid, header->macAddress2(), false /* should check FrameControl field */, -1, 0, loc, true /* only probed */ );
     qDebug( "Wellenreiter::invalid frame [possibly noise] detected!" );
 }
 
 
 void Wellenreiter::handleManagementFrameProbeResponse( OPacket* p, OWaveLanManagementPacket* response )
 {
 }
 
 
 void Wellenreiter::handleManagementFrameBeacon( OPacket* p, OWaveLanManagementPacket* beacon )
 {
     QString type;
     if ( beacon->canIBSS() )
     {
         type = "adhoc";
     }
     else if ( beacon->canESS() )
     {
         type = "managed";
     }
     else
     {
         qWarning( "Wellenreiter::invalid frame [possibly noise] detected!" );
         return;
     }
 
     OWaveLanManagementSSID* ssid = static_cast<OWaveLanManagementSSID*>( p->child( "802.11 SSID" ) );
     QString essid = ssid ? ssid->ID( true /* decloak */ ) : QString("<unknown>");
     OWaveLanManagementDS* ds = static_cast<OWaveLanManagementDS*>( p->child( "802.11 DS" ) );
     int channel = ds ? ds->channel() : -1;
 
     OWaveLanPacket* header = static_cast<OWaveLanPacket*>( p->child( "802.11" ) );
 
     GpsLocation loc( -111, -111 );
     if ( configwindow->enableGPS->isChecked() )
     {
         // TODO: add check if GPS is working!?
         qDebug( "Wellenreiter::gathering GPS data..." );
         loc = gps->position();
         qDebug( "Wellenreiter::GPS data received is ( %f , %f ) - dms string = '%s'", loc.latitude(), loc.longitude(), loc.dmsPosition().latin1() );
     }
 
     netView()->addNewItem( type, essid, header->macAddress2(), beacon->canPrivacy(), channel, 0, loc );
 
     // update graph window
     if ( ds )
     {
         OPrismHeaderPacket* prism = static_cast<OPrismHeaderPacket*>( p->child( "Prism" ) );
         if ( prism )
             graphwindow->traffic( ds->channel(), prism->signalStrength() );
         else
             graphwindow->traffic( ds->channel(), 95 );
     }
 }
 
 
 void Wellenreiter::handleControlFrame( OPacket* p, OWaveLanControlPacket* control )
 {
     OWaveLanPacket* header = static_cast<OWaveLanPacket*>( p->child( "802.11" ) );
 
     if ( control->controlType() == "Acknowledge" )
     {
         netView()->addNewItem( "adhoc", "<unknown>", header->macAddress1(), false, -1, 0, GpsLocation( -111, -111 ) );
     }
     else
     {
         qDebug( "Wellenreiter::handleControlFrame - please handle %s in a future version! :D", (const char*) control->controlType()  );
     }
 }
 
 
@@ -257,467 +263,467 @@ void Wellenreiter::handleWlanData( OPacket* p, OWaveLanDataPacket* data, OMacAdd
 {
     OWaveLanPacket* wlan = (OWaveLanPacket*) p->child( "802.11" );
     if ( wlan->fromDS() && !wlan->toDS() )
     {
         netView()->fromDStraffic( wlan->macAddress3(), wlan->macAddress1(), wlan->macAddress2() );
         from = wlan->macAddress3();
         to = wlan->macAddress2();
     }
     else if ( !wlan->fromDS() && wlan->toDS() )
     {
         netView()->toDStraffic( wlan->macAddress2(), wlan->macAddress3(), wlan->macAddress1() );
         from = wlan->macAddress2();
         to = wlan->macAddress3();
     }
     else if ( wlan->fromDS() && wlan->toDS() )
     {
         netView()->WDStraffic( wlan->macAddress4(), wlan->macAddress3(), wlan->macAddress1(), wlan->macAddress2() );
         from = wlan->macAddress4();
         to = wlan->macAddress3();
     }
     else
     {
         netView()->IBSStraffic( wlan->macAddress2(), wlan->macAddress1(), wlan->macAddress3() );
         from = wlan->macAddress2();
         to = wlan->macAddress1();
     }
 }
 
 
 void Wellenreiter::handleEthernetData( OPacket* p, OEthernetPacket* data, OMacAddress& from, OMacAddress& to )
 {
     from = data->sourceAddress();
     to = data->destinationAddress();
 
     netView()->addNewItem( "station", "<wired>", from, false, -1, 0, GpsLocation( -111, -111 ) );
 }
 
 
 void Wellenreiter::handleARPData( OPacket* p, OARPPacket*, OMacAddress& source, OMacAddress& dest )
 {
     OARPPacket* arp = (OARPPacket*) p->child( "ARP" );
     if ( arp )
     {
         qDebug( "Received ARP traffic (type '%s'): ", (const char*) arp->type() );
         if ( arp->type() == "REQUEST" )
         {
             netView()->identify( arp->senderMacAddress(), arp->senderIPV4Address().toString() );
         }
         else if ( arp->type() == "REPLY" )
         {
             netView()->identify( arp->senderMacAddress(), arp->senderIPV4Address().toString() );
             netView()->identify( arp->targetMacAddress(), arp->targetIPV4Address().toString() );
         }
     }
 }
 
 
 void Wellenreiter::handleIPData( OPacket* p, OIPPacket* ip, OMacAddress& source, OMacAddress& dest )
 {
     //TODO: Implement more IP based protocols
 
     ODHCPPacket* dhcp = (ODHCPPacket*) p->child( "DHCP" );
     if ( dhcp )
     {
         qDebug( "Received DHCP '%s' packet", (const char*) dhcp->type() );
         if ( dhcp->type() == "OFFER" )
         {
             qDebug( "DHCP: '%s' ('%s') seems to be a DHCP server.", (const char*) source.toString(), (const char*) dhcp->serverAddress().toString() );
             netView()->identify( source, dhcp->serverAddress().toString() );
             netView()->addService( "DHCP", source, dhcp->serverAddress().toString() );
         }
         else if ( dhcp->type() == "ACK" )
         {
             qDebug( "DHCP: '%s' ('%s') accepted the offered DHCP address.", (const char*) dhcp->clientMacAddress().toString(), (const char*) dhcp->yourAddress().toString() );
             netView()->identify( dhcp->clientMacAddress(), dhcp->yourAddress().toString() );
         }
     }
 }
 
 
 QObject* Wellenreiter::childIfToParse( OPacket* p, const QString& protocol )
 {
     if ( configwindow->parsePackets->isProtocolChecked( protocol ) )
         if ( configwindow->parsePackets->protocolAction( protocol ) == "Discard!" )
             return 0;
 
     return p->child( protocol );
 }
 
 
 bool Wellenreiter::checkDumpPacket( OPacket* p )
 {
     // go through all child packets and see if one is inside the child hierarchy for p
     // if so, do what the user requested (protocolAction), e.g. pass or discard
     if ( !configwindow->writeCaptureFile->isChecked() )
         return true; // semantic change - we're logging anyway now to /tmp/wellenreiter
 
     QObjectList* l = p->queryList();
     QObjectListIt it( *l );
     QObject* o;
 
     while ( (o = it.current()) != 0 )
     {
         QString name = it.current()->name();
         if ( configwindow->capturePackets->isProtocolChecked( name ) )
         {
             QString action = configwindow->capturePackets->protocolAction( name );
             qDebug( "capturePackets-action for '%s' seems to be '%s'", (const char*) name, (const char*) action );
             if ( action == "Discard" )
             {
                 logwindow->log( QString().sprintf( "(i) dump-discarding of '%s' packet requested.", (const char*) name ) );
                 return false;
             }
         }
         else
         {
             qDebug( "protocol '%s' not checked in capturePackets.", (const char*) name );
         }
     ++it;
     }
     return true;
 }
 
 
 void Wellenreiter::receivePacket( OPacket* p )
 {
     hexWindow()->add( p );
 
     if ( checkDumpPacket( p ) )
     {
         pcap->dump( p );
     }
 
     // check for a management frame
     OWaveLanManagementPacket* manage = static_cast<OWaveLanManagementPacket*>( childIfToParse( p, "802.11 Management" ) );
     if ( manage )
     {
         handleManagementFrame( p, manage );
         return;
     }
 
     // check for a control frame
     OWaveLanControlPacket* control = static_cast<OWaveLanControlPacket*>( childIfToParse( p, "802.11 Control" ) );
     if ( control )
     {
         handleControlFrame( p, control );
         return;
     }
 
     OMacAddress source;
     OMacAddress dest;
 
     //TODO: WEP check here
 
     // check for a wireless data frame
     OWaveLanDataPacket* wlan = static_cast<OWaveLanDataPacket*>( childIfToParse( p, "802.11 Data" ) );
     if ( wlan )
     {
         handleWlanData( p, wlan, source, dest );
     }
 
     // check for a wired data frame
     OEthernetPacket* eth = static_cast<OEthernetPacket*>( childIfToParse( p, "Ethernet" ) );
     if ( eth )
     {
         handleEthernetData( p, eth, source, dest );
     }
 
     // check for an arp frame since arp frames come in two flavours:
     // 802.11 encapsulates ARP data within IP packets while wired ethernet doesn't.
     OARPPacket* arp = static_cast<OARPPacket*>( childIfToParse( p, "ARP" ) );
     if ( arp )
     {
         handleARPData( p, arp, source, dest );
     }
 
     // check for a ip frame
     OIPPacket* ip = static_cast<OIPPacket*>( childIfToParse( p, "IP" ) );
     if ( ip )
     {
         handleIPData( p, ip, source, dest );
     }
 
     //handleNotification( p );
 
 }
 
 
 void Wellenreiter::stopClicked()
 {
     if ( iface )
     {
-        disconnect( SIGNAL( receivedPacket(OPacket*) ), this, SLOT( receivePacket(OPacket*) ) );
+        disconnect( SIGNAL( receivedPacket(Opie::Net::OPacket*) ), this, SLOT( receivePacket(Opie::Net::OPacket*) ) );
         disconnect( SIGNAL( hopped(int) ), this, SLOT( channelHopped(int) ) );
         iface->setChannelHopping(); // stop hopping channels
     }
     else
         killTimers();
 
     pcap->close();
     sniffing = false;
 
     if ( iface )
     {
         // switch off monitor mode
         iface->setMode( "managed" );
         // switch off promisc flag
         iface->setPromiscuousMode( false );
 
         system( "cardctl reset; sleep 1" ); //FIXME: Use OProcess
     }
 
     logwindow->log( "(i) Stopped Scanning." );
     assert( parent() );
     ( (QMainWindow*) parent() )->setCaption( "Wellenreiter II" );
 
     // message the user
     QMessageBox::information( this, "Wellenreiter II",
                               tr( "Your wireless card\nshould now be usable again." ) );
 
     sniffing = false;
     emit( stoppedSniffing() );
 
     #ifdef QWS
     if ( WellenreiterConfigWindow::instance()->disablePM->isChecked() )
     {
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Enable;
     }
     #else
         #warning FIXME: setScreenSaverMode is not operational on the X11 build
     #endif
 
     // print out statistics
     for( QMap<QString,int>::ConstIterator it = pcap->statistics().begin(); it != pcap->statistics().end(); ++it )
        statwindow->updateCounter( it.key(), it.data() );
 }
 
 
 void Wellenreiter::startClicked()
 {
     // get configuration from config window
 
     const QString& interface = configwindow->interfaceName->currentText();
     const int cardtype = configwindow->driverType();
     const int interval = configwindow->hoppingInterval();
 
     if ( ( interface == "" ) || ( cardtype == 0 ) )
     {
         QMessageBox::information( this, "Wellenreiter II",
                                   tr( "Your device is not\nproperly configured. Please reconfigure!" ) );
         return;
     }
 
     // configure device
     ONetwork* net = ONetwork::instance();
 
     // TODO: check if interface is wireless and support sniffing for non-wireless interfaces
 
     if ( !net->isPresent( interface ) )
     {
         QMessageBox::information( this, "Wellenreiter II",
                                   tr( "The configured device (%1)\nis not available on this system\n. Please reconfigure!" ).arg( interface ) );
         return;
     }
 
     iface = static_cast<OWirelessNetworkInterface*>(net->interface( interface )); // fails if network is not wireless!
     assert( iface );
 
     // bring device UP
     if ( cardtype != DEVTYPE_FILE )
     {
         iface->setUp( true );
         if ( !iface->isUp() )
         {
             QMessageBox::warning( this, "Wellenreiter II",
                                 tr( "Can't bring interface '%1' up:\n" ).arg( iface->name() ) + strerror( errno ) );
             return;
         }
     }
     // set monitor mode
     bool usePrism = configwindow->usePrismHeader();
 
     switch ( cardtype )
     {
         case DEVTYPE_CISCO: iface->setMonitoring( new OCiscoMonitoringInterface( iface, usePrism ) ); break;
         case DEVTYPE_WLAN_NG: iface->setMonitoring( new OWlanNGMonitoringInterface( iface, usePrism ) ); break;
         case DEVTYPE_HOSTAP: iface->setMonitoring( new OHostAPMonitoringInterface( iface, usePrism ) ); break;
         case DEVTYPE_ORINOCO: iface->setMonitoring( new OOrinocoMonitoringInterface( iface, usePrism ) ); break;
         case DEVTYPE_MANUAL: QMessageBox::information( this, "Wellenreiter II", tr( "Bring your device into\nmonitor mode now." ) ); break;
         case DEVTYPE_FILE: qDebug( "Wellenreiter: Capturing from file '%s'", (const char*) interface ); break;
         default: assert( 0 ); // shouldn't reach this
     }
 
     // switch device into monitor mode
     if ( cardtype < DEVTYPE_FILE )
     {
         if ( cardtype != DEVTYPE_MANUAL )
             iface->setMode( "monitor" );
         if ( iface->mode() != "monitor" )
         {
             if ( QMessageBox::warning( this, "Wellenreiter II",
                                   tr( "Can't set interface '%1'\ninto monitor mode:\n" ).arg( iface->name() ) + strerror( errno ) +
                                   tr( "\nContinue with limited functionality?" ), QMessageBox::Yes, QMessageBox::No ) == QMessageBox::No )
                 return;
         }
     }
 
     // open GPS device
     if ( configwindow->enableGPS->isChecked() )
     {
         qDebug( "Wellenreiter:GPS enabled @ %s:%d", (const char*) configwindow->gpsdHost->currentText(), configwindow->gpsdPort->value() );
         gps->open( configwindow->gpsdHost->currentText(), configwindow->gpsdPort->value() );
     }
 
     // open pcap and start sniffing
 
     if ( configwindow->writeCaptureFile->isChecked() ) // write to a user specified capture file?
     {
         dumpname = configwindow->captureFileName->text();
         if ( dumpname.isEmpty() ) dumpname = "captureFile";
         dumpname.append( '-' );
         dumpname.append( QTime::currentTime().toString().replace( QRegExp( ":" ), "-" ) );
         dumpname.append( ".wellenreiter" );
     }
     else // write it anyway ;)
     {
         dumpname = "/var/log/dump.wellenreiter";
     }
 
     if ( cardtype != DEVTYPE_FILE )
         pcap->open( interface );
     else
         pcap->open( QFile( interface ) );
 
     qDebug( "Wellenreiter:: dumping to %s", (const char*) dumpname );
     pcap->openDumpFile( dumpname );
 
     if ( !pcap->isOpen() )
     {
         QMessageBox::warning( this, "Wellenreiter II", tr( "Can't open packet capturer for\n'%1':\n" ).arg(
                               cardtype == DEVTYPE_FILE ? (const char*) interface : iface->name() ) + QString(strerror( errno ) ));
         return;
     }
 
     // set capturer to non-blocking mode
     pcap->setBlocking( false );
 
     // start channel hopper
     if ( cardtype != DEVTYPE_FILE )
     {
         logwindow->log( QString().sprintf( "(i) Starting channel hopper (d=%d ms)", configwindow->hopInterval->value() ) );
         iface->setChannelHopping( configwindow->hopInterval->value() ); //use interval from config window
     }
 
     if ( cardtype != DEVTYPE_FILE )
     {
         // connect socket notifier and start channel hopper
-        connect( pcap, SIGNAL( receivedPacket(OPacket*) ), this, SLOT( receivePacket(OPacket*) ) );
+        connect( pcap, SIGNAL( receivedPacket(Opie::Net::OPacket*) ), this, SLOT( receivePacket(Opie::Net::OPacket*) ) );
         connect( iface->channelHopper(), SIGNAL( hopped(int) ), this, SLOT( channelHopped(int) ) );
     }
     else
     {
         // start timer for reading packets
         startTimer( 100 );
     }
 
     logwindow->log( "(i) Started Scanning." );
     sniffing = true;
 
     #ifdef QWS
     if ( WellenreiterConfigWindow::instance()->disablePM->isChecked() )
     {
         QCopEnvelope( "QPE/System", "setScreenSaverMode(int)" ) << QPEApplication::Disable;
     }
     #else
         #warning FIXME: setScreenSaverMode is not operational on the X11 build
     #endif
 
     emit( startedSniffing() );
     if ( cardtype != DEVTYPE_FILE ) channelHopped( 6 ); // set title
     else
     {
         assert( parent() );
         ( (QMainWindow*) parent() )->setCaption( tr( "Wellenreiter II - replaying capture file..." ) );
     }
 }
 
 
 void Wellenreiter::timerEvent( QTimerEvent* )
 {
     qDebug( "Wellenreiter::timerEvent()" );
     OPacket* p = pcap->next();
     if ( !p ) // no more packets available
     {
         stopClicked();
     }
     else
     {
         receivePacket( p );
         delete p;
     }
 }
 
 
 void Wellenreiter::doAction( const QString& action, const QString& protocol, OPacket* p )
 {
     #ifdef QWS
     if ( action == "TouchSound" )
         ODevice::inst()->playTouchSound();
     else if ( action == "AlarmSound" )
         ODevice::inst()->playAlarmSound();
     else if ( action == "KeySound" )
         ODevice::inst()->playKeySound();
     else if ( action == "LedOn" )
         ODevice::inst()->setLedState( Led_Mail, Led_On );
     else if ( action == "LedOff" )
         ODevice::inst()->setLedState( Led_Mail, Led_Off );
     else if ( action == "LogMessage" )
         logwindow->log( QString().sprintf( "Got packet with protocol '%s'", (const char*) protocol ) );
     else if ( action == "MessageBox" )
         QMessageBox::information( this, "Notification!",
         QString().sprintf( "Got packet with protocol '%s'", (const char*) protocol ) );
     #else
     #warning Actions do not work with Qt/X11 yet
     #endif
 }
 
 void Wellenreiter::joinNetwork(const QString& type, const QString& essid, int channel, const QString& macaddr)
 {
     #ifdef QWS
     if ( !iface )
     {
         QMessageBox::warning( this, tr( "Can't do that!" ), tr( "No wireless\ninterface available." ) );
         return;
     }
 
     if ( sniffing )
     {
         QMessageBox::warning( this, tr( "Can't do that!" ), tr( "Stop sniffing before\njoining a net." ) );
         return;
     }
 
     qDebug( "joinNetwork() with Interface %s: %s, %s, %d, %s",
         (const char*) iface->name(),
         (const char*) type,
         (const char*) essid,
         channel,
         (const char*) macaddr );
 
     QCopEnvelope msg( "QPE/Application/networksettings", "wlan(QString,QString,QString)" );
     int count = 3;
     qDebug("sending %d messages",count);
     msg << QString("count") << QString::number(count);
     qDebug("msg >%s< Mode >%s<", iface->name(),type.latin1() );
     msg << QString(iface->name()) << QString("Mode") << type;
     qDebug("msg >%s< essid >%s<", iface->name(),essid.latin1());
     msg << QString(iface->name()) << QString("ESSID") << essid;
     qDebug("msg >%s< channel >%d<", iface->name(),channel);
     msg << QString(iface->name()) << QString("Channel") << channel;
 //    qDebug("msg >%s< mac >%s<", iface->name(),macaddr);
 //    msg << QString(iface->name()) << QString("MacAddr") << macaddr;
     #else
     QMessageBox::warning( this, tr( "Can't do that!" ), tr( "Function only available on Embedded build" ) );
     #endif
 
 }
 
diff --git a/noncore/net/wellenreiter/gui/wellenreiter.h b/noncore/net/wellenreiter/gui/wellenreiter.h
index d02813b..83299c9 100644
--- a/noncore/net/wellenreiter/gui/wellenreiter.h
+++ b/noncore/net/wellenreiter/gui/wellenreiter.h
@@ -1,107 +1,107 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef WELLENREITER_H
 #define WELLENREITER_H
 
 #include "wellenreiterbase.h"
 
 #ifdef QWS
 #include <opie2/odevice.h>
-using namespace Opie;
 #endif
 
 class QTimerEvent;
 class QPixmap;
-class OPacket;
-class OWaveLanManagementPacket;
-class OWaveLanControlPacket;
-class OWaveLanDataPacket;
-class OEthernetPacket;
-class OARPPacket;
-class OMacAddress;
-class OIPPacket;
-class OPacketCapturer;
-class OWirelessNetworkInterface;
+namespace Opie {namespace Net {class Opie::Net::OPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OWaveLanManagementPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OWaveLanControlPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OWaveLanDataPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OEthernetPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OARPPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OMacAddress;}}
+namespace Opie {namespace Net {class Opie::Net::OIPPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OPacket;}}
+namespace Opie {namespace Net {class Opie::Net::OWirelessNetworkInterface;}}
+namespace Opie {namespace Net {class Opie::Net::OPacketCapturer;}}
 class PacketView;
 class WellenreiterConfigWindow;
 class MLogWindow;
 class GPS;
 
 class Wellenreiter : public WellenreiterBase {
     Q_OBJECT
 
   public:
     Wellenreiter( QWidget* parent = 0 );
     ~Wellenreiter();
 
     void setConfigWindow( WellenreiterConfigWindow* cw );
     MScanListView* netView() const { return netview; };
     MLogWindow* logWindow() const { return logwindow; };
     PacketView* hexWindow() const { return hexwindow; };
     bool isDaemonRunning() const { return sniffing; };
     QString captureFileName() const { return dumpname; };
 
   public:
     bool sniffing;
 
   protected:
     virtual void timerEvent( QTimerEvent* );
 
   public slots:
     void initialTimer();
 
     void channelHopped(int);
-    void receivePacket(OPacket*);
+    void receivePacket(Opie::Net::OPacket*);
     void startClicked();
     void stopClicked();
 
     void joinNetwork(const QString&,const QString&,int,const QString&);
 
   signals:
     void startedSniffing();
     void stoppedSniffing();
 
   private:
-    void handleManagementFrame( OPacket* p, OWaveLanManagementPacket* );
-    void handleManagementFrameBeacon( OPacket* p, OWaveLanManagementPacket* );
-    void handleManagementFrameProbeRequest( OPacket* p, OWaveLanManagementPacket* );
-    void handleManagementFrameProbeResponse( OPacket* p, OWaveLanManagementPacket* );
-    void handleControlFrame( OPacket* p, OWaveLanControlPacket* control );
-    void handleWlanData( OPacket* p, OWaveLanDataPacket* data, OMacAddress& from, OMacAddress& to );
-    void handleEthernetData( OPacket* p, OEthernetPacket* data, OMacAddress& from, OMacAddress& to );
-    void handleARPData( OPacket* p, OARPPacket* arp, OMacAddress& from, OMacAddress& to );
-    void handleIPData( OPacket* p, OIPPacket* ip, OMacAddress& from, OMacAddress& to );
-    void handleNotification( OPacket* p );
-    void doAction( const QString& action, const QString& protocol, OPacket* p );
-    QObject* childIfToParse( OPacket* p, const QString& protocol );
-    bool checkDumpPacket( OPacket* p );
+    void handleManagementFrame( Opie::Net::OPacket* p, Opie::Net::OWaveLanManagementPacket* );
+    void handleManagementFrameBeacon( Opie::Net::OPacket* p, Opie::Net::OWaveLanManagementPacket* );
+    void handleManagementFrameProbeRequest( Opie::Net::OPacket* p, Opie::Net::OWaveLanManagementPacket* );
+    void handleManagementFrameProbeResponse( Opie::Net::OPacket* p, Opie::Net::OWaveLanManagementPacket* );
+    void handleControlFrame( Opie::Net::OPacket* p, Opie::Net::OWaveLanControlPacket* control );
+    void handleWlanData( Opie::Net::OPacket* p, Opie::Net::OWaveLanDataPacket* data, Opie::Net::OMacAddress& from, Opie::Net::OMacAddress& to );
+    void handleEthernetData( Opie::Net::OPacket* p, Opie::Net::OEthernetPacket* data, Opie::Net::OMacAddress& from, Opie::Net::OMacAddress& to );
+    void handleARPData( Opie::Net::OPacket* p, Opie::Net::OARPPacket* arp, Opie::Net::OMacAddress& from, Opie::Net::OMacAddress& to );
+    void handleIPData( Opie::Net::OPacket* p, Opie::Net::OIPPacket* ip, Opie::Net::OMacAddress& from, Opie::Net::OMacAddress& to );
+    void handleNotification( Opie::Net::OPacket* p );
+    void doAction( const QString& action, const QString& protocol, Opie::Net::OPacket* p );
+    QObject* childIfToParse( Opie::Net::OPacket* p, const QString& protocol );
+    bool checkDumpPacket( Opie::Net::OPacket* p );
 
   private:
     #ifdef QWS
-    OSystem _system;                // Opie Operating System identifier
+    Opie::Core::OSystem _system;                // Opie Operating System identifier
     #endif
 
     QString dumpname;
-    OWirelessNetworkInterface* iface;
-    OPacketCapturer* pcap;
+    Opie::Net::OWirelessNetworkInterface* iface;
+    Opie::Net::OPacketCapturer* pcap;
     WellenreiterConfigWindow* configwindow;
     GPS* gps;
 
     //void readConfig();
     //void writeConfig();
 };
 
 
 
 #endif
diff --git a/noncore/net/wellenreiter/gui/wellenreiterbase.cpp b/noncore/net/wellenreiter/gui/wellenreiterbase.cpp
index 3d0595d..f035e89 100644
--- a/noncore/net/wellenreiter/gui/wellenreiterbase.cpp
+++ b/noncore/net/wellenreiter/gui/wellenreiterbase.cpp
@@ -1,177 +1,180 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ***********************************************************************/
 
 #include "wellenreiterbase.h"
 
 #include <qlabel.h>
 #include <qlayout.h>
 
 #include "logwindow.h"
 #include "packetview.h"
 #include "scanlist.h"
 #include "statwindow.h"
 #include "graphwindow.h"
 
 #ifdef QWS
 #include <qpe/resource.h>
 #include <opie2/otabwidget.h>
 using namespace Opie;
 #else
 #include "resource.h"
 #include <qtabwidget.h>
 #endif
 
 
 /*
  *  Constructs a WellenreiterBase which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  */
+using namespace Opie::Ui;
+using namespace Opie::Ui;
+using namespace Opie::Ui;
 WellenreiterBase::WellenreiterBase( QWidget* parent,  const char* name, WFlags fl )
     : QWidget( parent, name, fl )
 {
     //ani1 = new QPixmap( Resource::loadPixmap( "wellenreiter/networks_rot0" ) );
     //ani2 = new QPixmap( Resource::loadPixmap( "wellenreiter/networks_rot90" ) );
     //ani3 = new QPixmap( Resource::loadPixmap( "wellenreiter/networks_rot180" ) );
     //ani4 = new QPixmap( Resource::loadPixmap( "wellenreiter/networks_rot270" ) );
 
     if ( !name )
         setName( "WellenreiterBase" );
     resize( 191, 294 );
 #ifdef QWS
     setCaption( tr( "Wellenreiter/Opie" ) );
 #else
     setCaption( tr( "Wellenreiter/X11" ) );
 #endif
     WellenreiterBaseLayout = new QVBoxLayout( this );
     WellenreiterBaseLayout->setSpacing( 2 );
     WellenreiterBaseLayout->setMargin( 0 );
 #ifdef QWS
     TabWidget = new OTabWidget( this, "TabWidget", OTabWidget::Global );
 #else
     TabWidget = new QTabWidget( this, "TabWidget" );
 #endif
     ap = new QWidget( TabWidget, "ap" );
     apLayout = new QVBoxLayout( ap );
     apLayout->setSpacing( 2 );
     apLayout->setMargin( 2 );
 
     //--------- NETVIEW TAB --------------
 
     netview = new MScanListView( ap );
     apLayout->addWidget( netview );
 
     //--------- GRAPH TAB --------------
 
     graphwindow = new MGraphWindow( TabWidget, "Graph" );
 
     //--------- LOG TAB --------------
 
     logwindow = new MLogWindow( TabWidget, "Log" );
 
     //--------- HEX TAB --------------
 
     hexwindow = new PacketView( TabWidget, "Hex" );
 
     //--------- STAT TAB --------------
 
     statwindow = new MStatWindow( TabWidget, "Stat" );
 
     //--------- ABOUT TAB --------------
 
     about = new QWidget( TabWidget, "about" );
     aboutLayout = new QGridLayout( about );
     aboutLayout->setSpacing( 6 );
     aboutLayout->setMargin( 11 );
 
     PixmapLabel1_3_2 = new QLabel( about, "PixmapLabel1_3_2" );
     PixmapLabel1_3_2->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, PixmapLabel1_3_2->sizePolicy().hasHeightForWidth() ) );
     PixmapLabel1_3_2->setFrameShape( QLabel::Panel );
     PixmapLabel1_3_2->setFrameShadow( QLabel::Sunken );
     PixmapLabel1_3_2->setLineWidth( 2 );
     PixmapLabel1_3_2->setMargin( 0 );
     PixmapLabel1_3_2->setMidLineWidth( 0 );
     PixmapLabel1_3_2->setPixmap(  Resource::loadPixmap( "wellenreiter/logo" ) );
     PixmapLabel1_3_2->setScaledContents( TRUE );
     PixmapLabel1_3_2->setAlignment( int( QLabel::AlignCenter ) );
 
     aboutLayout->addWidget( PixmapLabel1_3_2, 0, 0 );
 
     TextLabel1_4_2 = new QLabel( about, "TextLabel1_4_2" );
     QFont TextLabel1_4_2_font(  TextLabel1_4_2->font() );
     TextLabel1_4_2_font.setFamily( "adobe-helvetica" );
     TextLabel1_4_2_font.setPointSize( 10 );
     TextLabel1_4_2->setFont( TextLabel1_4_2_font );
     TextLabel1_4_2->setText( tr( "<p align=center>\n"
 "<hr>\n"
 "Michael 'Mickey' Lauer<br><hr>\n"
 "Max Moser<br>\n"
 "Martin J. Muench<br>\n"
 "<b>www.wellenreiter.net</b>\n"
 "</p>" ) );
     TextLabel1_4_2->setAlignment( int( QLabel::AlignCenter ) );
 
     aboutLayout->addWidget( TextLabel1_4_2, 1, 0 );
 
 #ifdef QWS
     TabWidget->addTab( ap, "wellenreiter/networks", tr( "Nets" ) );
     TabWidget->addTab( graphwindow, "wellenreiter/graph", tr( "Graph" ) );
     TabWidget->addTab( logwindow, "wellenreiter/log", tr( "Log" ) );
     TabWidget->addTab( hexwindow, "wellenreiter/hex", tr( "Hex" ) );
     TabWidget->addTab( statwindow, "wellenreiter/stat", tr( "Stat" ) );
     TabWidget->addTab( about, "wellenreiter/about", tr( "About" ) );
 #else
     TabWidget->addTab( ap, /* "wellenreiter/networks", */ tr( "Networks" ) );
     TabWidget->addTab( graphwindow, /* "wellenreiter/graph", */ tr( "Graph" ) );
     TabWidget->addTab( logwindow, /* "wellenreiter/log", */ tr( "Log" ) );
     TabWidget->addTab( hexwindow, /* "wellenreiter/hex", */ tr( "Hex" ) );
     TabWidget->addTab( statwindow, /* "wellenreiter/hex", */ tr( "Stat" ) );
     TabWidget->addTab( about, /* "wellenreiter/about", */ tr( "About" ) );
 #endif
     WellenreiterBaseLayout->addWidget( TabWidget );
 
 #ifdef QWS
     TabWidget->setCurrentTab( tr( "Nets" ) );
 #endif
 
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 WellenreiterBase::~WellenreiterBase()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 /*
  *  Main event handler. Reimplemented to handle application
  *  font changes
  */
 bool WellenreiterBase::event( QEvent* ev )
 {
     bool ret = QWidget::event( ev );
     if ( ev->type() == QEvent::ApplicationFontChange ) {
 	//QFont Log_2_font(  Log_2->font() );
 	//Log_2_font.setFamily( "adobe-courier" );
 	//Log_2_font.setPointSize( 8 );
 	//Log_2->setFont( Log_2_font );
 	QFont TextLabel1_4_2_font(  TextLabel1_4_2->font() );
 	TextLabel1_4_2_font.setFamily( "adobe-helvetica" );
 	TextLabel1_4_2_font.setPointSize( 10 );
 	TextLabel1_4_2->setFont( TextLabel1_4_2_font );
     }
     return ret;
 }
 
diff --git a/noncore/net/wellenreiter/gui/wellenreiterbase.h b/noncore/net/wellenreiter/gui/wellenreiterbase.h
index 126aad2..e40b699 100644
--- a/noncore/net/wellenreiter/gui/wellenreiterbase.h
+++ b/noncore/net/wellenreiter/gui/wellenreiterbase.h
@@ -1,77 +1,77 @@
 /**********************************************************************
 ** Copyright (C) 2002-2004 Michael 'Mickey' Lauer.  All rights reserved.
 **
 ** This file is part of Wellenreiter II.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef WELLENREITERBASE_H
 #define WELLENREITERBASE_H
 
 #include <qvariant.h>
 #include <qwidget.h>
 class QVBoxLayout;
 class QHBoxLayout;
 class QGridLayout;
 class QLabel;
 class MScanListView;
 class MScanListItem;
 class QPushButton;
 class MLogWindow;
 class MStatWindow;
 class MGraphWindow;
 class PacketView;
 
 #ifdef QWS
 #include <opie2/otabwidget.h>
 using namespace Opie;
 #else
 class QTabWidget;
 #endif
 
 class WellenreiterBase : public QWidget
 {
     Q_OBJECT
 
 public:
     WellenreiterBase( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     ~WellenreiterBase();
 
 #ifdef QWS
-    OTabWidget* TabWidget;
+    Opie::Ui::OTabWidget* TabWidget;
 #else
     QTabWidget* TabWidget;
 #endif
     QWidget* ap;
     MScanListView* netview;
     MLogWindow* logwindow;
     PacketView* hexwindow;
     MStatWindow* statwindow;
     MGraphWindow* graphwindow;
     QWidget* about;
     QLabel* PixmapLabel1_3_2;
     QLabel* TextLabel1_4_2;
 
 protected:
     QVBoxLayout* WellenreiterBaseLayout;
     QVBoxLayout* apLayout;
     QGridLayout* aboutLayout;
     bool event( QEvent* );
 
     QPixmap* ani1;
     QPixmap* ani2;
     QPixmap* ani3;
     QPixmap* ani4;
 
 
 };
 
 #endif // WELLENREITERBASE_H