compile fixes

5 files changed, 96 insertions, 93 deletions

diff --git a/kmicromail/libmailwrapper/abstractmail.cpp b/kmicromail/libmailwrapper/abstractmail.cpp
index 2d7533c..8ee112c 100644
--- a/kmicromail/libmailwrapper/abstractmail.cpp
+++ b/kmicromail/libmailwrapper/abstractmail.cpp
@@ -2,25 +2,25 @@
 #include "abstractmail.h"
 #include "imapwrapper.h"
 #include "pop3wrapper.h"
 #include "nntpwrapper.h"
 #include "mhwrapper.h"
 #include "mailtypes.h"
 #include <qpe/global.h>
 
 
 #include <qprogressbar.h>
 #include <qapplication.h>
 #include <qmessagebox.h>
-
+#include <klocale.h>
 #include <kdecore/kstandarddirs.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);
 }
@@ -138,58 +138,58 @@ QString AbstractMail::draftFolder()
 
 /* temporary - will be removed when implemented in all classes */
 void AbstractMail::deleteMails(const QString &,const QValueList<Opie::Core::OSmartPointer<RecMail> > &)
 {
 }
 void AbstractMail::deleteMailList(const QValueList<RecMailP>&target)
 {
     //qDebug("AbstractMail::deleteMailList:: Please reimplement! ");
     // this is currently re-implemented in pop3wrapper and imapwrapper
     int iii = 0;
     int count = target.count(); 
     QProgressBar wid ( count );
-    wid.setCaption( tr("Deleting ..."));
+    wid.setCaption( i18n("Deleting ..."));
     wid.show();
     while (iii < count ) {   
-        Global::statusMessage(tr("Delete message %1 of %2").arg(iii).arg(count)); 
+        Global::statusMessage(i18n("Delete message %1 of %2").arg(iii).arg(count)); 
         wid.setProgress( iii ); 
         wid.raise();
         qApp->processEvents();
         RecMailP mail = (*target.at( iii ));
         deleteMail(mail);
         ++iii;
     }
 }
 
 void AbstractMail::downloadNewMails(const FolderP&fromFolder, AbstractMail*targetMail )
 {
     //qDebug("AbstractMail::downloadNewMails %s ", fromFolder->getName().latin1());
     // get local folder
     Account * acc = getAccount();
     if ( !acc ) return;
     QString lfName = acc->getLocalFolder();
     if ( lfName.isEmpty() )
         lfName = acc->getAccountName();
     // create local folder
     if ( !targetMail->createMbox(lfName))
         {
-            QMessageBox::critical(0,tr("Error creating new Folder"),
-                                  tr("Error while creating new folder\n%1\n\nCancelling action.").arg(lfName));
+            QMessageBox::critical(0,i18n("Error creating new Folder"),
+                                  i18n("Error while creating new folder\n%1\n\nCancelling action.").arg(lfName));
             return;
         }
     QValueList<RecMailP> t;
     listMessages(fromFolder->getName(),t,acc->getMaxMailSize() );
     if ( t.count() == 0 ) {
         qDebug("There are no new messages %s", fromFolder->getName().latin1());
-        Global::statusMessage(tr("There are no new messages"));
+        Global::statusMessage(i18n("There are no new messages"));
         return;
     }
     QValueList<RecMailP> e;
     targetMail->listMessages(lfName,e,acc->getMaxMailSize() );
     //qDebug("target has mails %d ", e.count());
     QValueList<RecMailP> n; 
     int iii = 0;
     int count = t.count();  
     while (iii < count ) {  
         RecMailP r = (*t.at( iii ));
         bool found = false; 
         int jjj = 0;
@@ -201,29 +201,29 @@ void AbstractMail::downloadNewMails(const FolderP&fromFolder, AbstractMail*targe
                 break;
             }
             ++jjj;   
         }
         if ( !found ) {
             //qDebug("AAAdate  *%s*  ", r->isodate.latin1() );
             n.append( r );
         }
         ++iii;
     } 
     qDebug("Downloaded %d messages ",n.count() );
     if ( n.count() == 0 ) {
-        Global::statusMessage(tr("There are no new messages"));
+        Global::statusMessage(i18n("There are no new messages"));
         return;
     }
     mvcpMailList( n,lfName,targetMail,!acc->getLeaveOnServer());
-    Global::statusMessage(tr("Downloaded %1 messages").arg(n.count()));
+    Global::statusMessage(i18n("Downloaded %1 messages").arg(n.count()));
     
 #if 0
  QValueList<RecMailP> t;
  listMessages(fromFolder->getName(),t, maxSizeInKb);
  mvcpMailList( t,targetFolder,targetWrapper,moveit);
 #endif 
 
 }
 void AbstractMail::mvcpAllMails(const FolderP&fromFolder,
     const QString&targetFolder,AbstractMail*targetWrapper,bool moveit, int maxSizeInKb)
 {
  QValueList<RecMailP> t;
@@ -231,31 +231,31 @@ void AbstractMail::mvcpAllMails(const FolderP&fromFolder,
  mvcpMailList( t,targetFolder,targetWrapper,moveit);
 
 }
 void AbstractMail::mvcpMailList(const QValueList<RecMailP>& t,
                                 const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     encodedString*st = 0;
     int iii = 0;
     int count = t.count();
     if ( count == 0 )
         return;
     // wel, processevents is qite strange, we need a widget for getting  
-    // Global::statusMessage(tr("Copy2 message %1").arg(iii)); displaye
+    // Global::statusMessage(i18n("Copy2 message %1").arg(iii)); displaye
 
     QProgressBar wid ( count );
-    wid.setCaption( tr("Copying ..."));
+    wid.setCaption( i18n("Copying..."));
     wid.show();
     while (iii < count ) {  
-        Global::statusMessage(tr("Copy message %1 of %2").arg(iii).arg(count));
+        Global::statusMessage(i18n("Copy message %1 of %2").arg(iii).arg(count));
         wid.setProgress( iii ); 
         wid.raise();
         qApp->processEvents();
         RecMailP r = (*t.at( iii ));
         st = fetchRawBody(r);
         if (st) {
             targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder);
             delete st;
         }
         ++iii;
     } 
     if (moveit) {
diff --git a/kmicromail/libmailwrapper/imapwrapper.cpp b/kmicromail/libmailwrapper/imapwrapper.cpp
index 8150453..3aec13d 100644
--- a/kmicromail/libmailwrapper/imapwrapper.cpp
+++ b/kmicromail/libmailwrapper/imapwrapper.cpp
@@ -39,44 +39,44 @@ int IMAPwrapper::selectMbox(const QString&mbox)
     int err = mailimap_select( m_imap, (char*)mbox.latin1());
     if ( err != MAILIMAP_NO_ERROR ) {
         m_Lastmbox = "";
         return err;
     }
     m_Lastmbox = mbox;
     return err;
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     //qDebug("imap progress %d of %d ",current,maximum  );
-    //Global::statusMessage(tr("Downloading message %1 of %2").arg( current).arg(maximum));
+    //Global::statusMessage(i18n("Downloading message %1 of %2").arg( current).arg(maximum));
     //qApp->processEvents()
     static int last = 0;
     if ( last != current )
         IMAPwrapper::progress();
     last = current;
 }
 void IMAPwrapper::progress( QString m )
 {
  
     static QString mProgrMess;
     if ( m != QString::null ) {
         mProgrMess = m;
         mCurrent = 1;
         return;
     }
     QString mess;
     //qDebug("progress ");
-    if (  mMax ) mess = mProgrMess +tr(" message %1 of %2").arg( mCurrent++).arg(mMax);
-    else mess = mProgrMess +tr(" message %1").arg( mCurrent++);
+    if (  mMax ) mess = mProgrMess +i18n(" message %1 of %2").arg( mCurrent++).arg(mMax);
+    else mess = mProgrMess +i18n(" message %1").arg( mCurrent++);
     Global::statusMessage(mess);
     //qDebug("Progress %s %s", mess.latin1(), m.latin1());
     qApp->processEvents();
 }
 bool IMAPwrapper::start_tls(bool force_tls)
 {
     int err;
     bool try_tls;
     mailimap_capability_data * cap_data = 0;
 
     err = mailimap_capability(m_imap,&cap_data);
     if (err != MAILIMAP_NO_ERROR) {
@@ -91,25 +91,25 @@ bool IMAPwrapper::start_tls(bool force_tls)
             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!"));
+            Global::statusMessage(i18n("Server has no TLS support!"));
             try_tls = false;
         } else {
             mailstream_low * low;
             mailstream_low * new_low;
             low = mailstream_get_low(m_imap->imap_stream);
             if (!low) {
                 try_tls = false;
             } else {
                 int fd = mailstream_low_get_fd(low);
                 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
                     mailstream_low_free(low);
                     mailstream_set_low(m_imap->imap_stream, new_low);
@@ -179,47 +179,47 @@ void IMAPwrapper::login()
         err = mailimap_socket_connect( m_imap, (char*)server.latin1(), port );
     }
 
     if ( err != MAILIMAP_NO_ERROR &&
          err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
          err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
          QString failure = "";
          if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) {
             failure="Connection refused";
          } else {
             failure="Unknown failure";
          }
-         Global::statusMessage(tr("error connecting imap server: %1").arg(failure));
+         Global::statusMessage(i18n("error connecting imap server: %1").arg(failure));
          mailimap_free( m_imap );
          m_imap = 0;
          return;
     }
 
     if (!ssl) {
         try_tls = start_tls(force_tls);
     }
 
     bool ok = true;
     if (force_tls && !try_tls) {
-        Global::statusMessage(tr("Server has no TLS support!"));
+        Global::statusMessage(i18n("Server has no TLS support!"));
         ok = false;
     }
 
 
     /* login */
 
     if (ok) {
         err = mailimap_login_simple( m_imap, (char*)user.latin1(), (char*)pass.latin1() );
         if ( err != MAILIMAP_NO_ERROR ) {
-            Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response));
+            Global::statusMessage(i18n("error logging in imap server: %1").arg(m_imap->imap_response));
             ok = false;
         }
     }
     if (!ok) {
         err = mailimap_close( m_imap );
         mailimap_free( m_imap );
         m_imap = 0;
     }
 }
 
 void IMAPwrapper::logout()
 {
@@ -247,32 +247,32 @@ void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSma
         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"));
+            Global::statusMessage(i18n("Mailbox has no mails"));
             return;
         } else {
         }
-        progress( tr("Fetch "));     
+        progress( i18n("Fetch "));     
         mMax = last;
         //qDebug("last %d ", last);
-        Global::statusMessage(tr("Fetching header list"));
+        Global::statusMessage(i18n("Fetching header list"));
         qApp->processEvents();
         /* the range has to start at 1!!! not with 0!!!! */
         //LR the access to web.de imap server is no working with value 1
         //qDebug("interval %d - %d ", tryAgain, last-1+tryAgain  );
         set = mailimap_set_new_interval( tryAgain, last );
         fetchType = mailimap_fetch_type_new_fetch_att_list_empty();
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate());
         mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size());
 
         err = mailimap_fetch( m_imap, set, fetchType, &result );
@@ -290,30 +290,30 @@ void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSma
                 //qDebug("iii %d ",i);
                 msg_att = (mailimap_msg_att*)current->data;
                 RecMail*m = parse_list_result(msg_att);
                 if (m) {
                     if ( maxSizeInKb == 0 || m->Msgsize()<=maxSizeInKb*1024 ) { 
                         m->setNumber(i);
                         m->setMbox(mailbox);
                         m->setWrapper(this);
                         target.append(m);
                     }
                 }
             }
-            Global::statusMessage(tr("Mailbox has %1 mails").arg(target.count()));
+            Global::statusMessage(i18n("Mailbox has %1 mails").arg(target.count()));
         } else {
             --tryAgain;
             --tryAgain;//disabled tryagain by adding this line
             if ( tryAgain < 0 )
-                Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response));
+                Global::statusMessage(i18n("Error fetching headers: %1").arg(m_imap->imap_response));
             else
                 qDebug("try again... ");
         }
     
         if (result) mailimap_fetch_list_free(result);
     }
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
 {
     const char *path, *mask;
     int err = MAILIMAP_NO_ERROR;
@@ -324,25 +324,25 @@ QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
 
     QValueList<FolderP>* folders = new QValueList<FolderP>();
     login();
     if (!m_imap) {
         return folders;
     }
 
 /*
  * First we have to check for INBOX 'cause it sometimes it's not inside the path.
  * We must not forget to filter them out in next loop!
  * it seems like ugly code. and yes - it is ugly code. but the best way.
  */
-    Global::statusMessage(tr("Fetching folder list"));
+    Global::statusMessage(i18n("Fetching folder list"));
     qApp->processEvents();
     QString temp;
     mask = "INBOX" ;
     mailimap_mailbox_list *list;
     err = mailimap_list( m_imap, (char*)"", (char*)mask, &result );
     QString del;
     bool selectable = true;
     bool no_inferiors = false;
     if ( err == MAILIMAP_NO_ERROR ) {
         current = result->first;
         for ( int i = result->count; i > 0; i-- ) {
             list = (mailimap_mailbox_list *) current->data;
@@ -960,31 +960,31 @@ void IMAPwrapper::deleteMailList(const QValueList<RecMailP>&target)
     int err;
     login();
     //#endif
     if (!m_imap) {
         return;
     }
     int iii = 0;
     int count = target.count();
     // qDebug("imap remove count %d ", count); 
 
     
     mMax = count;
-    progress( tr("Delete")); 
+    progress( i18n("Delete")); 
 
     QProgressBar wid ( count );
-    wid.setCaption( tr("Deleting ..."));
+    wid.setCaption( i18n("Deleting ..."));
     wid.show();
     while (iii < count ) {
-        Global::statusMessage(tr("Delete message %1 of %2").arg(iii).arg(count));
+        Global::statusMessage(i18n("Delete message %1 of %2").arg(iii).arg(count));
         wid.setProgress( iii ); 
         wid.raise();
         qApp->processEvents();
         RecMailP mail = (*target.at( iii ));
         //#if 0
         //qDebug("IMAP remove %d %d ", iii, mail->getNumber() );
         err = selectMbox(mail->getMbox());
         if ( err != MAILIMAP_NO_ERROR ) {
             return;
         }
         flist = mailimap_flag_list_new_empty();
         mailimap_flag_list_add(flist,mailimap_flag_new_deleted());
@@ -994,34 +994,34 @@ void IMAPwrapper::deleteMailList(const QValueList<RecMailP>&target)
         mailimap_set_free( set );
         mailimap_store_att_flags_free(store_flags);
 
         if (err != MAILIMAP_NO_ERROR) {
             // odebug << "error deleting mail: " << m_imap->imap_response << "" << oendl; 
             return;
         }
         // odebug << "deleting mail: " << m_imap->imap_response << "" << oendl; 
         /* should we realy do that at this moment? */
    
         // err = mailimap_expunge(m_imap);
         //if (err != MAILIMAP_NO_ERROR) {
-        //    Global::statusMessage(tr("Error deleting mails: %s").arg(m_imap->imap_response));
+        //    Global::statusMessage(i18n("Error deleting mails: %s").arg(m_imap->imap_response));
         // }
         //#endif
         //deleteMail( mail);
         ++iii;
     }
     //qDebug("Deleting imap mails... ");
         err = mailimap_expunge(m_imap);
         if (err != MAILIMAP_NO_ERROR) {
-            Global::statusMessage(tr("Error deleting mails: %s").arg(m_imap->imap_response));
+            Global::statusMessage(i18n("Error deleting mails: %s").arg(m_imap->imap_response));
         }
 }
 void IMAPwrapper::deleteMail(const RecMailP&mail)
 {
     mailimap_flag_list*flist;
     mailimap_set *set;
     mailimap_store_att_flags * store_flags;
     int err;
     login();
     if (!m_imap) {
         return;
     }
@@ -1037,25 +1037,25 @@ void IMAPwrapper::deleteMail(const RecMailP&mail)
     mailimap_set_free( set );
     mailimap_store_att_flags_free(store_flags);
 
     if (err != MAILIMAP_NO_ERROR) {
         // odebug << "error deleting mail: " << m_imap->imap_response << "" << oendl; 
         return;
     }
     // odebug << "deleting mail: " << m_imap->imap_response << "" << oendl; 
     /* should we realy do that at this moment? */
   
     err = mailimap_expunge(m_imap);
     if (err != MAILIMAP_NO_ERROR) {
-        Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response));
+        Global::statusMessage(i18n("error deleting mail: %s").arg(m_imap->imap_response));
     }
     //qDebug("IMAPwrapper::deleteMail 2");
     
 }
 
 void IMAPwrapper::answeredMail(const RecMailP&mail)
 {
     mailimap_flag_list*flist;
     mailimap_set *set;
     mailimap_store_att_flags * store_flags;
     int err;
     login();
@@ -1120,87 +1120,87 @@ int IMAPwrapper::deleteAllMail(const FolderP&folder)
         return 0;
     }
     mailimap_flag_list*flist;
     mailimap_set *set;
     mailimap_store_att_flags * store_flags;
     int err = selectMbox(folder->getName());
     if ( err != MAILIMAP_NO_ERROR ) {
         return 0;
     }
 
     int last = m_imap->imap_selection_info->sel_exists;
     if (last == 0) {
-        Global::statusMessage(tr("Mailbox has no mails!"));
+        Global::statusMessage(i18n("Mailbox has no mails!"));
         return 0;
     }
     flist = mailimap_flag_list_new_empty();
     mailimap_flag_list_add(flist,mailimap_flag_new_deleted());
     store_flags = mailimap_store_att_flags_new_set_flags(flist);
     set = mailimap_set_new_interval( 1, last );
     err = mailimap_store(m_imap,set,store_flags);
     mailimap_set_free( set );
     mailimap_store_att_flags_free(store_flags);
     if (err != MAILIMAP_NO_ERROR) {
-        Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response));
+        Global::statusMessage(i18n("error deleting mail: %s").arg(m_imap->imap_response));
         return 0;
     }
     // odebug << "deleting mail: " << m_imap->imap_response << "" << oendl; 
     /* should we realy do that at this moment? */
     err = mailimap_expunge(m_imap);
     if (err != MAILIMAP_NO_ERROR) {
-        Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response));
+        Global::statusMessage(i18n("error deleting mail: %s").arg(m_imap->imap_response));
         return 0;
     }
     // odebug << "Delete successfull " << m_imap->imap_response << "" << oendl; 
     return 1;
 }
 
 int IMAPwrapper::createMbox(const QString&folder,const FolderP&parentfolder,const QString& delemiter,bool getsubfolder)
 {
     if (folder.length()==0) return 0;
     login();
     if (!m_imap) {return 0;}
     QString pre = account->getPrefix();
     if (delemiter.length()>0 && pre.findRev(delemiter)!=pre.length()-1) {
         pre+=delemiter;
     }
     if (parentfolder) {
         pre += parentfolder->getDisplayName()+delemiter;
     }
     pre+=folder;
     if (getsubfolder) {
         if (delemiter.length()>0) {
             pre+=delemiter;
         } else {
-            Global::statusMessage(tr("Cannot create folder %1 for holding subfolders").arg(pre));
+            Global::statusMessage(i18n("Cannot create folder %1 for holding subfolders").arg(pre));
             return 0;
         }
     }
     // odebug << "Creating " << pre.latin1() << "" << oendl; 
     int res = mailimap_create(m_imap,pre.latin1());
     if (res != MAILIMAP_NO_ERROR) {
-        Global::statusMessage(tr("%1").arg(m_imap->imap_response));
+        Global::statusMessage(i18n("%1").arg(m_imap->imap_response));
         return 0;
     }
     return 1;
 }
 
 int IMAPwrapper::deleteMbox(const FolderP&folder)
 {
     if (!folder) return 0;
     login();
     if (!m_imap) {return 0;}
     int res = mailimap_delete(m_imap,folder->getName());
     if (res != MAILIMAP_NO_ERROR) {
-        Global::statusMessage(tr("%1").arg(m_imap->imap_response));
+        Global::statusMessage(i18n("%1").arg(m_imap->imap_response));
         return 0;
     }
     return 1;
 }
 
 void IMAPwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     mailimap_status_att_list * att_list =0;
     mailimap_mailbox_data_status * status=0;
     clistiter * cur = 0;
     int r = 0;
     target_stat.message_count = 0;
@@ -1265,46 +1265,46 @@ const QString&IMAPwrapper::getName()const
 encodedString* IMAPwrapper::fetchRawBody(const RecMailP&mail)
 {
     // dummy
     QValueList<int> path;
     return fetchRawPart(mail,path,false);
 }
 
 void IMAPwrapper::mvcpAllMails(const FolderP&fromFolder,
                                const QString&targetFolder,AbstractMail*targetWrapper,bool moveit, int maxSizeInKb)
 {
     if (targetWrapper != this || maxSizeInKb > 0 ) { 
         mMax = 0;
-        progress( tr("Copy"));
+        progress( i18n("Copy"));
         AbstractMail::mvcpAllMails(fromFolder,targetFolder,targetWrapper,moveit, maxSizeInKb);
         //qDebug("IMAPwrapper::mvcpAllMails::Using generic");
         // odebug << "Using generic" << oendl; 
         return;
     }
     mailimap_set *set = 0;
     login();
     if (!m_imap) {
         return;
     }
     int err = selectMbox(fromFolder->getName());
     if ( err != MAILIMAP_NO_ERROR ) {
         return;
     }
-    Global::statusMessage( tr("Copying mails on server...") );
+    Global::statusMessage( i18n("Copying mails on server...") );
     int last = m_imap->imap_selection_info->sel_exists;
     set = mailimap_set_new_interval( 1, last );
     err = mailimap_copy(m_imap,set,targetFolder.latin1());
     mailimap_set_free( set );
     if ( err != MAILIMAP_NO_ERROR ) {
-        QString error_msg = tr("Error copy mails: %1").arg(m_imap->imap_response);
+        QString error_msg = i18n("Error copy mails: %1").arg(m_imap->imap_response);
         Global::statusMessage(error_msg);
         // odebug << error_msg << oendl; 
         return;
     }
     if (moveit) {
         deleteAllMail(fromFolder);
     }
 }
 
 void IMAPwrapper::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
 {
     if (targetWrapper != this) {
@@ -1316,21 +1316,21 @@ void IMAPwrapper::mvcpMail(const RecMailP&mail,const QString&targetFolder,Abstra
     login();
     if (!m_imap) {
         return;
     }
     int err = selectMbox(mail->getMbox());
     if ( err != MAILIMAP_NO_ERROR ) {
         return;
     }
     set = mailimap_set_new_single(mail->getNumber());
     err = mailimap_copy(m_imap,set,targetFolder.latin1());
     mailimap_set_free( set );
     if ( err != MAILIMAP_NO_ERROR ) {
-        QString error_msg = tr("error copy mail: %1").arg(m_imap->imap_response);
+        QString error_msg = i18n("error copy mail: %1").arg(m_imap->imap_response);
         Global::statusMessage(error_msg);
         // odebug << error_msg << oendl; 
         return;
     }
     if (moveit) {
         deleteMail(mail);
     }
 }
diff --git a/kmicromail/libmailwrapper/mboxwrapper.cpp b/kmicromail/libmailwrapper/mboxwrapper.cpp
index 39dd156..0cdbae4 100644
--- a/kmicromail/libmailwrapper/mboxwrapper.cpp
+++ b/kmicromail/libmailwrapper/mboxwrapper.cpp
@@ -1,18 +1,19 @@
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <stdlib.h>
+#include <klocale.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);
     }
@@ -35,25 +36,25 @@ void MBOXwrapper::listMessages(const QString & mailbox, QValueList<RecMailP> &ta
     if (r != MAIL_NO_ERROR) {
         //odebug << "Error initializing mbox" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
 
     parseList(target,folder->fld_session,mailbox);
 
     mailfolder_disconnect(folder);
     mailfolder_free(folder);
     mailstorage_free(storage);
-    Global::statusMessage(tr("Mailbox has %1 mail(s)").arg(target.count()));
+    Global::statusMessage(i18n("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* MBOXwrapper::listFolders()
 {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     QDir dir(MBOXPath);
     if (!dir.exists()) return folders;
     dir.setFilter(QDir::Files|QDir::Writable|QDir::Readable);
     QStringList entries = dir.entryList();
     QStringList::ConstIterator it = entries.begin();
     for (;it!=entries.end();++it) {
         FolderP inb=new Folder(*it,"/");
@@ -134,83 +135,83 @@ RecBodyP MBOXwrapper::fetchBody( const RecMailP &mail )
 
 void MBOXwrapper::mbox_progress( size_t current, size_t maximum )
 {
     ; // << "MBOX " << current << " von " << maximum << "" << oendl; 
 }
 
 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."));
+        Global::statusMessage(i18n("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"));
+        Global::statusMessage(i18n("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"));
+        Global::statusMessage(i18n("Error init folder"));
         return;
     }
     r = mailmbox_append_message(f,msg,length);
     if (r != MAIL_NO_ERROR) {
-        Global::statusMessage(tr("Error writing to message folder"));
+        Global::statusMessage(i18n("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"));
+        Global::statusMessage(i18n("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()));
+        Global::statusMessage(i18n("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()));
+        Global::statusMessage(i18n("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;
 }
@@ -248,83 +249,83 @@ void MBOXwrapper::deleteMails(mailmbox_folder*f,const QValueList<RecMailP> &targ
 
 int MBOXwrapper::deleteAllMail(const FolderP&tfolder)
 {
     if (!tfolder) return 0;
     QString p = MBOXPath+"/"+tfolder->getDisplayName();
     int res = 1;
 
     mailfolder*folder = 0;
     mailmessage_list*l=0;
     mailstorage*storage = mailstorage_new(NULL);
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     if (r != MAIL_NO_ERROR) {
-        Global::statusMessage(tr("Error initializing mbox"));
+        Global::statusMessage(i18n("Error initializing mbox"));
         res = 0;
     }
     if (res) {
         folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
         r = mailfolder_connect(folder);
         if (r != MAIL_NO_ERROR) {
-            Global::statusMessage(tr("Error initializing mbox"));
+            Global::statusMessage(i18n("Error initializing mbox"));
             res = 0;
         }
     }
     if (res) {
         r = mailsession_get_messages_list(folder->fld_session,&l);
         if (r != MAIL_NO_ERROR) {
             ; // << "Error message list" << oendl; 
             res=0;
         }
     }
     for(unsigned int i = 0 ; l!= 0 && res==1 && i < carray_count(l->msg_tab) ; ++i) {
         r = mailsession_remove_message(folder->fld_session,i+1);
         if (r != MAIL_NO_ERROR) {
-            Global::statusMessage(tr("Error deleting mail %1").arg(i+1));
+            Global::statusMessage(i18n("Error deleting mail %1").arg(i+1));
             res = 0;
             break;
         }
     }
     if (l) mailmessage_list_free(l);
     if (folder) mailfolder_free(folder);
     if (storage) mailstorage_free(storage);
     return res;
 }
 
 int MBOXwrapper::deleteMbox(const FolderP&tfolder)
 {
     if (!tfolder) return 0;
     QString p = MBOXPath+"/"+tfolder->getDisplayName();
     QFile fi(p);
     if (!fi.exists()) {
-        Global::statusMessage(tr("Mailbox doesn't exist."));
+        Global::statusMessage(i18n("Mailbox doesn't exist."));
         return 0;
     }
     if (!fi.remove()) {
-        Global::statusMessage(tr("Error deleting Mailbox."));
+        Global::statusMessage(i18n("Error deleting Mailbox."));
         return 0;
     }
     return 1;
 }
 
 void MBOXwrapper::statusFolder(folderStat&target_stat,const QString & mailbox)
 {
     mailfolder*folder = 0;
     mailstorage*storage = mailstorage_new(NULL);
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     QString p = MBOXPath+"/"+mailbox;
     QFile fi(p);
     if (!fi.exists()) {
-        Global::statusMessage(tr("Mailbox doesn't exist."));
+        Global::statusMessage(i18n("Mailbox doesn't exist."));
         return;
     }
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
     r = mailfolder_connect(folder);
     r = mailsession_status_folder(folder->fld_session,(char*)mailbox.latin1(),&target_stat.message_count,
         &target_stat.message_recent,&target_stat.message_unseen);
     if (folder) mailfolder_free(folder);
     if (storage) mailstorage_free(storage);
 }
 
 MAILLIB::ATYPE MBOXwrapper::getType()const
diff --git a/kmicromail/libmailwrapper/pop3wrapper.cpp b/kmicromail/libmailwrapper/pop3wrapper.cpp
index 9d52f52..2888f7c 100644
--- a/kmicromail/libmailwrapper/pop3wrapper.cpp
+++ b/kmicromail/libmailwrapper/pop3wrapper.cpp
@@ -1,19 +1,20 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 #include <stdlib.h>
 #include "pop3wrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 #include <libetpan/libetpan.h>
 
+#include <klocale.h>
 
 #include <qpe/global.h>
 #include <qfile.h>
 #include <qprogressbar.h>
 #include <qapplication.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() {
@@ -98,25 +99,25 @@ RecBodyP POP3wrapper::fetchBody( const RecMailP &mail ) {
 
     return body;
 }
 
 void POP3wrapper::listMessages(const QString &, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb )
 {
     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", false, maxSizeInKb);
-    Global::statusMessage( tr("Mailbox contains %1 mail(s)").arg(res_messages));
+    Global::statusMessage( i18n("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;
 
     QString server,user, pass;
     uint16_t port;
@@ -156,25 +157,25 @@ void POP3wrapper::login()
     } else if ( conntypeset == 0 ) {
         conntype = CONNECTION_TYPE_TRY_STARTTLS;
     }
 
     //(ssl?CONNECTION_TYPE_TLS:CONNECTION_TYPE_PLAIN);
 
     pop3_mailstorage_init(m_pop3,(char*)server.latin1(), port, NULL, conntype, POP3_AUTH_TYPE_PLAIN,
                           (char*)user.latin1(),(char*)pass.latin1(),0,0,0);
 
     err = mailstorage_connect(m_pop3);
     if (err != MAIL_NO_ERROR) {
         ; // odebug << QString( "FEHLERNUMMER %1" ).arg(  err ) << oendl; 
-        Global::statusMessage(tr("Error %1 initializing folder").arg( err ));
+        Global::statusMessage(i18n("Error %1 initializing folder").arg( err ));
         mailstorage_free(m_pop3);
         m_pop3 = 0;
     } else {
         mailsession * session = m_pop3->sto_session;
         mailpop3 * mail =  ( (  pop3_session_state_data * )session->sess_data )->pop3_session;
         if (mail) {
             mail->pop3_progr_fun = &pop3_progress;
         }
     }
 }
 
 void POP3wrapper::logout()
@@ -193,79 +194,79 @@ QValueList<Opie::Core::OSmartPointer<Folder> >* POP3wrapper::listFolders() {
     return folders;
 }
 
 void POP3wrapper::deleteMailList(const QValueList<RecMailP>&target)
 {
     login();
     if (!m_pop3)
         return;
     int iii = 0;
     int count = target.count(); 
 
     QProgressBar wid ( count );
-    wid.setCaption( tr("Deleting ..."));
+    wid.setCaption( i18n("Deleting ..."));
     wid.show();
     while (iii < count ) {  
-        Global::statusMessage(tr("Delete message %1 of %2").arg(iii).arg(count));
+        Global::statusMessage(i18n("Delete message %1 of %2").arg(iii).arg(count));
         wid.setProgress( iii ); 
         wid.raise();
         qApp->processEvents();
         //qDebug("delete ");
         RecMailP mail = (*target.at( iii ));
         int err = mailsession_remove_message(m_pop3->sto_session,mail->getNumber());
         if (err != MAIL_NO_ERROR) {
-            Global::statusMessage(tr("Error deleting mail"));
+            Global::statusMessage(i18n("Error deleting mail"));
         }
         ++iii;
     }
 }
 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"));
+        Global::statusMessage(i18n("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"));
+        Global::statusMessage(i18n("Error getting folder info"));
         return 0;
     }
 
 
 
     QProgressBar wid ( result );
-    wid.setCaption( tr("Deleting ..."));
+    wid.setCaption( i18n("Deleting ..."));
     wid.show();
     for (unsigned int i = 0; i < result; ++i) { 
-        Global::statusMessage(tr("Delete message %1 of %2").arg(i).arg(result));
+        Global::statusMessage(i18n("Delete message %1 of %2").arg(i).arg(result));
         wid.setProgress( i ); 
         wid.raise();
         qApp->processEvents();
       
         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));
+            Global::statusMessage(i18n("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;
diff --git a/kmicromail/libmailwrapper/smtpwrapper.cpp b/kmicromail/libmailwrapper/smtpwrapper.cpp
index d5a528c..dee1477 100644
--- a/kmicromail/libmailwrapper/smtpwrapper.cpp
+++ b/kmicromail/libmailwrapper/smtpwrapper.cpp
@@ -5,24 +5,25 @@
 #include "mailtypes.h"
 #include "sendmailprogress.h"
 
 //#include <opie2/odebug.h>
 //#include <qt.h>
 #include <qapplication.h>
 #include <qmessagebox.h>
 #include <stdlib.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include <libetpan/libetpan.h>
+#include <klocale.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 );
@@ -35,61 +36,61 @@ 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" );
+        return i18n( "No error" );
     case MAILSMTP_ERROR_UNEXPECTED_CODE:
-        return tr( "Unexpected error code" );
+        return i18n( "Unexpected error code" );
     case MAILSMTP_ERROR_SERVICE_NOT_AVAILABLE:
-        return tr( "Service not available" );
+        return i18n( "Service not available" );
     case MAILSMTP_ERROR_STREAM:
-        return tr( "Stream error" );
+        return i18n( "Stream error" );
     case MAILSMTP_ERROR_HOSTNAME:
-        return tr( "gethostname() failed" );
+        return i18n( "gethostname() failed" );
     case MAILSMTP_ERROR_NOT_IMPLEMENTED:
-        return tr( "Not implemented" );
+        return i18n( "Not implemented" );
     case MAILSMTP_ERROR_ACTION_NOT_TAKEN:
-        return tr( "Error, action not taken" );
+        return i18n( "Error, action not taken" );
     case MAILSMTP_ERROR_EXCEED_STORAGE_ALLOCATION:
-        return tr( "Data exceeds storage allocation" );
+        return i18n( "Data exceeds storage allocation" );
     case MAILSMTP_ERROR_IN_PROCESSING:
-        return tr( "Error in processing" );
+        return i18n( "Error in processing" );
     case MAILSMTP_ERROR_STARTTLS_NOT_SUPPORTED:
-        return tr( "Starttls not supported" );
+        return i18n( "Starttls not supported" );
         //      case MAILSMTP_ERROR_INSUFFISANT_SYSTEM_STORAGE:
-        //        return tr( "Insufficient system storage" );
+        //        return i18n( "Insufficient system storage" );
     case MAILSMTP_ERROR_MAILBOX_UNAVAILABLE:
-        return tr( "Mailbox unavailable" );
+        return i18n( "Mailbox unavailable" );
     case MAILSMTP_ERROR_MAILBOX_NAME_NOT_ALLOWED:
-        return tr( "Mailbox name not allowed" );
+        return i18n( "Mailbox name not allowed" );
     case MAILSMTP_ERROR_BAD_SEQUENCE_OF_COMMAND:
-        return tr( "Bad command sequence" );
+        return i18n( "Bad command sequence" );
     case MAILSMTP_ERROR_USER_NOT_LOCAL:
-        return tr( "User not local" );
+        return i18n( "User not local" );
     case MAILSMTP_ERROR_TRANSACTION_FAILED:
-        return tr( "Transaction failed" );
+        return i18n( "Transaction failed" );
     case MAILSMTP_ERROR_MEMORY:
-        return tr( "Memory error" );
+        return i18n( "Memory error" );
     case MAILSMTP_ERROR_CONNECTION_REFUSED:
-        return tr( "Connection refused" );
+        return i18n( "Connection refused" );
     default:
-        return tr( "Unknown error code" );
+        return i18n( "Unknown error code" );
     }
 }
 
 
 void SMTPwrapper::progress( size_t current, size_t maximum ) {
     if (SMTPwrapper::sendProgress) {
         SMTPwrapper::sendProgress->setSingleMail(current, maximum );
         qApp->processEvents();
     }
 }
 
 void SMTPwrapper::storeMail(const char*mail, size_t length, const QString&box) {
@@ -143,26 +144,26 @@ bool SMTPwrapper::smtpSend( mailmime *mail,bool later) {
     }
     if (rcpts)
         smtp_address_list_free( rcpts );
     return result;
 }
 
 void SMTPwrapper::storeFailedMail(const char*data,unsigned int size, const char*failuremessage)
 {
     if (data) {
         storeMail(data,size,"Sendfailed");
     }
     if (failuremessage) {
-        QMessageBox::critical(0,tr("Error sending mail"),
-            tr("<center>%1</center>").arg(failuremessage));
+        QMessageBox::critical(0,i18n("Error sending mail"),
+            i18n("<center>%1</center>").arg(failuremessage));
     }
 }
 
 int SMTPwrapper::start_smtp_tls()
 {
     if (!m_smtp) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int err = mailesmtp_starttls(m_smtp);
     if (err != MAILSMTP_NO_ERROR) return err;
     mailstream_low * low;
     mailstream_low * new_low;
@@ -212,77 +213,77 @@ void SMTPwrapper::connect_server()
 
     int err = MAILSMTP_NO_ERROR;
     ; // odebug << "Servername " << server << " at port " << port << "" << oendl; 
     if ( ssl ) {
         ; // odebug << "SSL session" << oendl; 
         err = mailsmtp_ssl_connect( m_smtp, server.latin1(), port );
     } else {
         ; // odebug << "No SSL session" << oendl; 
         err = mailsmtp_socket_connect( m_smtp, server.latin1(), port );
     }
     if ( err != MAILSMTP_NO_ERROR ) {
         ; // odebug << "Error init connection" << oendl; 
-        failuretext = tr("Error init SMTP connection: %1").arg(mailsmtpError(err));
+        failuretext = i18n("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));
+            failuretext = i18n("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));
+        failuretext = i18n("Error init SMTP tls: %1").arg(mailsmtpError(err));
     }
 
     if (result==1 && m_SmtpAccount->getLogin() ) {
         ; // odebug << "smtp with auth" << oendl; 
         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();
                 pass = login.getPassword();
             } else {
                 result = 0;
-                failuretext=tr("Login aborted - storing mail to localfolder");
+                failuretext=i18n("Login aborted - storing mail to localfolder");
             }
         } else {
             user = m_SmtpAccount->getUser();
             pass = m_SmtpAccount->getPassword();
         }
         ; // odebug << "session->auth: " << m_smtp->auth << "" << oendl; 
         if (result) {
             err = mailsmtp_auth( m_smtp, (char*)user.latin1(), (char*)pass.latin1() );
             if ( err == MAILSMTP_NO_ERROR ) {
                 ; // odebug << "auth ok" << oendl; 
             } else {
-                failuretext = tr("Authentification failed");
+                failuretext = i18n("Authentification failed");
                 result = 0;
             }
         }
     }
 }
 
 void SMTPwrapper::disc_server()
 {
     if (m_smtp) {
         mailsmtp_quit( m_smtp );
         mailsmtp_free( m_smtp );
         m_smtp = 0;
@@ -291,25 +292,25 @@ void SMTPwrapper::disc_server()
 
 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));
+            failuretext=i18n("Error sending mail: %1").arg(mailsmtpError(err));
             result = 0;
         }
     } else {
         result = 0;
     }
 
     if (!result) {
         storeFailedMail(data,size,failuretext);
     } else {
         ; // odebug << "Mail sent." << oendl; 
         storeMail(data,size,"Sent");
     }
@@ -424,26 +425,26 @@ bool SMTPwrapper::flushOutbox() {
         } 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"));
+            QMessageBox::critical(0,i18n("Error sending mail"),
+                                  i18n("Error sending queued mail - breaking"));
             returnValue = false;
             break;
         }
         mailsToRemove.append((*mailsToSend.begin()));
         mailsToSend.remove(mailsToSend.begin());
         sendProgress->setCurrentMails(mailsToRemove.count());
     }
     if (reset_user_value) {
         m_SmtpAccount->setUser(oldUser);
         m_SmtpAccount->setPassword(oldPw);
     }
     Config cfg( "mail" );