diff --git a/kmbox/mbox.cpp b/kmbox/mbox.cpp
index e2821784d..7a203afc2 100644
--- a/kmbox/mbox.cpp
+++ b/kmbox/mbox.cpp
@@ -1,687 +1,688 @@
 /*
     Copyright (c) 1996-1998 Stefan Taferner <taferner@kde.org>
     Copyright (c) 2009 Bertjan Broeksema <b.broeksema@kdemail.net>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     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., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 
     NOTE: Most of the code inside here is an slightly adjusted version of
           kdepim/kmail/kmfoldermbox.cpp. This is why I added a copyright line
           for Stefan Taferner.
 
           Bertjan Broeksema, april 2009
 */
 
 #include "mbox.h"
 
+#include <QtCore/QFileInfo>
+#include <QtCore/QProcess>
+#include <QtCore/QReadWriteLock>
+
+#include <fcntl.h>
 #include <kdebug.h>
 #include <klocalizedstring.h>
 #include <kshell.h>
 #include <kstandarddirs.h>
-#include <QtCore/QFileInfo>
-#include <QtCore/QReadWriteLock>
-#include <QtCore/QProcess>
-#include <fcntl.h>
 #include <kurl.h>
 
 class MBox::Private
 {
   public:
     Private() : mInitialMboxFileSize( 0 )
     {}
 
     ~Private()
     {
       if ( mMboxFile.isOpen() )
         mMboxFile.close();
     }
 
     void close()
     {
       if ( mMboxFile.isOpen() )
         mMboxFile.close();
 
       mFileLocked = false;
     }
 
     QByteArray mAppendedEntries;
     QList<MsgInfo> mEntries;
     bool mFileLocked;
     quint64 mInitialMboxFileSize;
     LockType mLockType;
     QFile mMboxFile;
     QString mLockFileName;
     bool mReadOnly;
 };
 
 static QString sMBoxSeperatorRegExp( "^From .*[0-9][0-9]:[0-9][0-9]" );
 
 /// private static methods.
 
-QByteArray quoteAndEncode(const QString &str)
+QByteArray quoteAndEncode( const QString &str )
 {
-  return QFile::encodeName(KShell::quoteArg(str));
+  return QFile::encodeName( KShell::quoteArg( str ) );
 }
 
 /// public methods.
 
 MBox::MBox()
-  : d(new Private())
+  : d( new Private() )
 {
   // Set some sane defaults
   d->mFileLocked = false;
   d->mLockType = None; //
 }
 
 MBox::~MBox()
 {
   if ( d->mFileLocked )
     unlock();
 
   d->close();
 
   delete d;
 }
 
 qint64 MBox::appendEntry( const MessagePtr &entry )
 {
   if ( d->mMboxFile.fileName().isEmpty() )
     return -1; // It doesn't make sense to add entries when we don't have an reference file.
 
   const QByteArray rawEntry = escapeFrom( entry->encodedContent() );
 
   if ( rawEntry.size() <= 0 ) {
     kDebug() << "Message added to folder `" << d->mMboxFile.fileName()
              << "' contains no data. Ignoring it.";
     return -1;
   }
 
   int nextOffset = d->mAppendedEntries.size(); // Offset of the appended message
 
   // Make sure the byte array is large enough to check for an end character.
   // Then check if the required newlines are there.
   if ( nextOffset < 1 && d->mMboxFile.size() > 0 ) { // Empty, add one empty line
     d->mAppendedEntries.append( "\n");
     ++nextOffset;
   } else if ( nextOffset == 1 && d->mAppendedEntries.at( 0 ) != '\n' ) {
     // This should actually not happen, but catch it anyway.
-    if (d->mMboxFile.size() < 0 ) {
-      d->mAppendedEntries.append( "\n");
+    if ( d->mMboxFile.size() < 0 ) {
+      d->mAppendedEntries.append( "\n" );
       ++nextOffset;
     }
-  } else if (nextOffset >= 2) {
+  } else if ( nextOffset >= 2 ) {
     if ( d->mAppendedEntries.at( nextOffset - 1 ) != '\n' ) {
       if ( d->mAppendedEntries.at( nextOffset ) != '\n' ) {
         d->mAppendedEntries.append( "\n\n" );
         nextOffset += 2;
       } else {
         d->mAppendedEntries.append( "\n" );
         ++nextOffset;
       }
     }
   }
 
   d->mAppendedEntries.append( mboxMessageSeparator( rawEntry ) );
   d->mAppendedEntries.append( rawEntry );
   if ( rawEntry[rawEntry.size() - 1] != '\n' ) {
     d->mAppendedEntries.append( "\n\n" );
   } else {
     d->mAppendedEntries.append( "\n" );
   }
 
   MsgInfo info;
   info.first = d->mInitialMboxFileSize + nextOffset;
   info.second = rawEntry.size();
   d->mEntries << info;
 
   return d->mInitialMboxFileSize + nextOffset;
 }
 
 QList<MsgInfo> MBox::entryList(const QSet<quint64> &deletedItems) const
 {
   QList<MsgInfo> result;
 
   foreach ( const MsgInfo &info, d->mEntries ) {
     if ( !deletedItems.contains( info.first ) )
       result << info;
   }
 
   return result;
 }
 
 bool MBox::load( const QString &fileName )
 {
   if ( d->mFileLocked )
     return false;
 
-  d->mMboxFile.setFileName( KUrl(fileName).path() );
+  d->mMboxFile.setFileName( KUrl( fileName ).path() );
   if ( !d->mMboxFile.exists() && !d->mMboxFile.open( QIODevice::WriteOnly ) )
     return false;
 
   if ( ! lock() )
     return false;
 
   d->mAppendedEntries.clear();
   d->mEntries.clear();
 
   QRegExp regexp( sMBoxSeperatorRegExp );
   QByteArray line;
   QByteArray prevSeparator;
   quint64 offs = 0; // The offset of the next message to read.
 
   while ( !d->mMboxFile.atEnd() ) {
     quint64 pos = d->mMboxFile.pos();
 
     line = d->mMboxFile.readLine();
 
-    if ( regexp.indexIn(line) >= 0 || d->mMboxFile.atEnd() ) {
+    if ( regexp.indexIn( line ) >= 0 || d->mMboxFile.atEnd() ) {
       // Found the separator or at end of file, the message starts at offs
       quint64 msgSize = pos - offs;
 
       if( pos > 0 ) {
         // This is not the separator of the first mail in the file. If pos == 0
         // than we matched the separator of the first mail in the file.
         MsgInfo info;
         info.first = offs;
 
         // There is always a blank line and a seperator line between two emails.
         // Sometimes there are two '\n' characters added to the email (i.e. when
         // the mail self did not end with a '\n' char) and sometimes only one to
         // achieve this. When reading the file it is not possible to see which
         // was the case.
         if ( d->mMboxFile.atEnd() )
           info.second = msgSize; // We use readLine so there's no additional '\n'
         else
           info.second = msgSize - 1;
 
         // Don't add the seperator size and the newline up to the message size.
         info.second -= prevSeparator.size() + 1;
 
         d->mEntries << info;
       }
 
-      if ( regexp.indexIn(line) >= 0 )
+      if ( regexp.indexIn( line ) >= 0 )
         prevSeparator = line;
 
       offs += msgSize; // Mark the beginning of the next message.
     }
   }
 
   return unlock(); // FIXME: What if unlock fails?
 }
 
 bool MBox::lock()
 {
   if ( d->mMboxFile.fileName().isEmpty() )
     return false; // We cannot lock if there is no file loaded.
 
   d->mFileLocked = false;
 
   QStringList args;
   int rc = 0;
 
   switch(d->mLockType)
   {
     case ProcmailLockfile:
       args << "-l20" << "-r5";
-      if (!d->mLockFileName.isEmpty())
+      if ( !d->mLockFileName.isEmpty() )
         args << quoteAndEncode(d->mLockFileName);
       else
         args << quoteAndEncode(d->mMboxFile.fileName() + ".lock");
 
       rc = QProcess::execute("lockfile", args);
-      if(rc != 0) {
+      if( rc != 0 ) {
         kDebug() << "lockfile -l20 -r5 " << d->mMboxFile.fileName()
                  << ": Failed ("<< rc << ") switching to read only mode";
         d->mReadOnly = true; // In case the MBox object was created read/write we
                              // set it to read only when locking failed.
       } else {
         d->mFileLocked = true;
       }
       break;
 
     case MuttDotlock:
-      args << quoteAndEncode(d->mMboxFile.fileName());
-      rc = QProcess::execute("mutt_dotlock", args);
+      args << quoteAndEncode( d->mMboxFile.fileName() );
+      rc = QProcess::execute( "mutt_dotlock", args );
 
-      if(rc != 0) {
+      if( rc != 0 ) {
         kDebug() << "mutt_dotlock " << d->mMboxFile.fileName()
                  << ": Failed (" << rc << ") switching to read only mode";
         d->mReadOnly = true; // In case the MBox object was created read/write we
                           // set it to read only when locking failed.
       } else {
         d->mFileLocked = true;
       }
       break;
 
     case MuttDotlockPrivileged:
-      args << "-p" << quoteAndEncode(d->mMboxFile.fileName());
-      rc = QProcess::execute("mutt_dotlock", args);
+      args << "-p" << quoteAndEncode( d->mMboxFile.fileName() );
+      rc = QProcess::execute( "mutt_dotlock", args );
 
-      if(rc != 0) {
+      if( rc != 0 ) {
         kDebug() << "mutt_dotlock -p " << d->mMboxFile.fileName() << ":"
                  << ": Failed (" << rc << ") switching to read only mode";
         d->mReadOnly = true;
       } else {
         d->mFileLocked = true;
       }
       break;
 
     case None:
       d->mFileLocked = true;
       break;
     default:
       break;
   }
 
   if ( d->mFileLocked ) {
     if ( !open() ) {
       const bool unlocked = unlock();
       Q_ASSERT( unlocked ); // If this fails we're in trouble.
       Q_UNUSED( unlocked );
     }
   }
 
   return d->mFileLocked;
 }
 
 static bool lessThanByOffset( const MsgInfo &left, const MsgInfo &right )
 {
   return left.first < right.first;
 }
 
 bool MBox::purge( const QSet<quint64> &deletedItems )
 {
   if ( d->mMboxFile.fileName().isEmpty() )
     return false; // No file loaded yet.
 
   if ( deletedItems.isEmpty() )
     return true; // Nothing to do.
 
   if ( !lock() )
     return false;
 
   foreach ( quint64 offset, deletedItems ) {
     d->mMboxFile.seek( offset );
     QByteArray line = d->mMboxFile.readLine();
     QRegExp regexp( sMBoxSeperatorRegExp );
 
     if ( regexp.indexIn(line) < 0 ) {
       qDebug() << "Found invalid seperator at:" << offset;
       unlock();
       return false; // The file is messed up or the index is incorrect.
     }
   }
 
   // All entries are deleted, so just resize the file to a size of 0.
   if ( deletedItems.size() == d->mEntries.size() ) {
     d->mEntries.clear();
     d->mMboxFile.resize( 0 );
     kDebug() << "Purge comleted successfully, unlocking the file.";
     return unlock();
   }
 
   qSort( d->mEntries.begin(), d->mEntries.end(), lessThanByOffset );
   quint64 writeOffset = 0;
   bool writeOffSetInitialized = false;
   QList<MsgInfo> resultingEntryList;
 
   quint64 origFileSize = d->mMboxFile.size();
 
   qDebug() << "ENTRIES:" << d->mEntries;
   QListIterator<MsgInfo> i( d->mEntries );
   while ( i.hasNext() ) {
     MsgInfo entry = i.next();
 
     if ( deletedItems.contains( entry.first ) && !writeOffSetInitialized ) {
       writeOffset = entry.first;
       writeOffSetInitialized = true;
     } else if ( writeOffSetInitialized
                 && writeOffset < entry.first
                 && !deletedItems.contains( entry.first ) ) {
       // The current message doesn't have to be deleted, but must be moved.
       // First determine the size of the entry that must be moved.
       quint64 entrySize = 0;
       if ( i.hasNext() ) {
         entrySize = i.next().first - entry.first;
         i.previous(); // Go back to make sure that we also handle the next entry.
       } else {
         entrySize = origFileSize - entry.first;
       }
 
       Q_ASSERT( entrySize > 0 ); // MBox entries really cannot have a size <= 0;
 
       // we map the whole area of the file starting at the writeOffset up to the
       // message that have to be moved into memory. This includes eventually the
       // messages that are the deleted between the first deleted message
       // encountered and the message that has to be moved.
       quint64 mapSize = entry.first + entrySize - writeOffset;
 
       // Now map writeOffSet + mapSize into mem.
       uchar *memArea = d->mMboxFile.map( writeOffset, mapSize );
 
       // Now read the entry that must be moved to writeOffset.
       quint64 startOffset = entry.first - writeOffset;
       memmove( memArea, memArea + startOffset, entrySize );
 
       d->mMboxFile.unmap( memArea );
 
       resultingEntryList << MsgInfo( writeOffset, entry.second );
       writeOffset += entrySize;
     } else if ( !deletedItems.contains( entry.first ) ) {
       // Unmoved and not deleted entry, can only occure before the first deleted
       // entry.
       Q_ASSERT( !writeOffSetInitialized );
       resultingEntryList << entry;
     }
   }
 
   // Chop off remaining entry bits.
   d->mMboxFile.resize( writeOffset );
   d->mEntries = resultingEntryList;
 
   kDebug() << "Purge comleted successfully, unlocking the file.";
   return unlock(); // FIXME: What if this fails? It will return false but the
                    // file has changed.
 }
 
 KMime::Message *MBox::readEntry(quint64 offset)
 {
   bool wasLocked = d->mFileLocked;
   if ( ! wasLocked )
     if ( ! lock() )
       return 0;
 
   // TODO: Add error handling in case locking failed.
 
   Q_ASSERT( d->mFileLocked );
   Q_ASSERT( d->mMboxFile.isOpen() );
   Q_ASSERT( d->mMboxFile.size() > 0 );
 
   if ( offset > static_cast<quint64>( d->mMboxFile.size() ) ) {
     unlock();
     return 0;
   }
 
   d->mMboxFile.seek(offset);
 
   QByteArray line = d->mMboxFile.readLine();
   QRegExp regexp( sMBoxSeperatorRegExp );
 
-  if (regexp.indexIn(line) < 0) {
+  if ( regexp.indexIn( line ) < 0) {
     unlock();
     return 0; // The file is messed up or the index is incorrect.
   }
 
   QByteArray message;
   line = d->mMboxFile.readLine();
-  while (regexp.indexIn(line) < 0 && !d->mMboxFile.atEnd()) {
+  while ( regexp.indexIn( line ) < 0 && !d->mMboxFile.atEnd() ) {
     message += line;
     line = d->mMboxFile.readLine();
   }
 
   // Remove te last '\n' added by writeEntry.
-  if (message.endsWith('\n'))
+  if ( message.endsWith( '\n' ) )
     message.chop(1);
 
-  unescapeFrom(message.data(), message.size());
+  unescapeFrom( message.data(), message.size() );
 
   if ( ! wasLocked ) {
     const bool unlocked = unlock();
     Q_ASSERT( unlocked );
     Q_UNUSED( unlocked );
   }
 
   KMime::Message *mail = new KMime::Message();
   mail->setContent( KMime::CRLFtoLF( message ) );
   mail->parse();
 
   return mail;
 }
 
-QByteArray MBox::readEntryHeaders(quint64 offset)
+QByteArray MBox::readEntryHeaders( quint64 offset )
 {
   bool wasLocked = d->mFileLocked;
   if ( ! wasLocked )
     lock();
 
   Q_ASSERT( d->mFileLocked );
-  Q_ASSERT(d->mMboxFile.isOpen());
-  Q_ASSERT(d->mMboxFile.size() > 0);
-  Q_ASSERT(static_cast<quint64>(d->mMboxFile.size()) > offset);
+  Q_ASSERT( d->mMboxFile.isOpen() );
+  Q_ASSERT( d->mMboxFile.size() > 0 );
+  Q_ASSERT( static_cast<quint64>(d->mMboxFile.size()) > offset );
 
-  d->mMboxFile.seek(offset);
+  d->mMboxFile.seek( offset );
   QByteArray headers;
   QByteArray line = d->mMboxFile.readLine();
 
-  while (!line[0] == '\n') {
+  while ( !line[0] == '\n' ) {
     headers += line;
     line = d->mMboxFile.readLine();
   }
 
   if ( ! wasLocked )
     unlock();
 
   return headers;
 }
 
 bool MBox::save( const QString &fileName )
 {
   if ( !fileName.isEmpty() && KUrl( fileName ).path() != d->mMboxFile.fileName() )
   {
     // File saved != file loaded from
     return false; // FIXME: Implement this case
   }
 
   if ( d->mAppendedEntries.size() == 0 )
     return true; // Nothing to do.
 
   if ( !lock() )
     return false;
 
   Q_ASSERT( d->mMboxFile.isOpen() );
 
   d->mMboxFile.seek( d->mMboxFile.size() );
   d->mMboxFile.write( d->mAppendedEntries );
   d->mAppendedEntries.clear();
 
   return unlock();
 }
 
 bool MBox::setLockType(LockType ltype)
 {
   if (d->mFileLocked) {
     kDebug() << "File is currently locked.";
     return false; // Don't change the method if the file is currently locked.
   }
 
   switch ( ltype ) {
     case ProcmailLockfile:
       if ( KStandardDirs::findExe( "lockfile" ).isEmpty() ) {
         kDebug() << "Could not find the lockfile executable";
         return false;
       }
       break;
     case MuttDotlock: // fall through
     case MuttDotlockPrivileged:
-      if (KStandardDirs::findExe("mutt_dotlock").isEmpty()) {
+      if ( KStandardDirs::findExe("mutt_dotlock").isEmpty() ) {
         kDebug() << "Could not find the mutt_dotlock executable";
         return false;
       }
       break;
     default:
       break; // We assume fcntl available and lock_none doesn't need a check.
   }
 
   d->mLockType = ltype;
   return true;
 }
 
-void MBox::setLockFile(const QString &lockFile)
+void MBox::setLockFile( const QString &lockFile )
 {
   d->mLockFileName = lockFile;
 }
 
 bool MBox::unlock()
 {
   int rc = 0;
   QStringList args;
 
   switch( d->mLockType )
   {
     case ProcmailLockfile:
       // QFile::remove returns true on succes so negate the result.
-      if (!d->mLockFileName.isEmpty())
-        rc = !QFile(d->mLockFileName).remove();
+      if ( !d->mLockFileName.isEmpty() )
+        rc = !QFile( d->mLockFileName ).remove();
       else
-        rc = !QFile(d->mMboxFile.fileName() + ".lock").remove();
+        rc = !QFile( d->mMboxFile.fileName() + ".lock" ).remove();
       break;
 
     case MuttDotlock:
-      args << "-u" << quoteAndEncode(d->mMboxFile.fileName());
-      rc = QProcess::execute("mutt_dotlock", args);
+      args << "-u" << quoteAndEncode( d->mMboxFile.fileName() );
+      rc = QProcess::execute( "mutt_dotlock", args );
       break;
 
     case MuttDotlockPrivileged:
-      args << "-u" << "-p" << quoteAndEncode(d->mMboxFile.fileName());
-      rc = QProcess::execute("mutt_dotlock", args);
+      args << "-u" << "-p" << quoteAndEncode( d->mMboxFile.fileName() );
+      rc = QProcess::execute( "mutt_dotlock", args );
       break;
 
     case None: // Fall through.
     default:
       break;
   }
 
   if ( rc == 0 ) // Unlocking succeeded
     d->mFileLocked = false;
 
   d->mMboxFile.close();
 
   return !d->mFileLocked;
 }
 
 /// private methods
 
 bool MBox::open()
 {
   if ( d->mMboxFile.isOpen() )
     return true;  // already open
 
   if ( !d->mMboxFile.open( QIODevice::ReadWrite ) ) { // messages file
     kDebug() << "Cannot open mbox file `" << d->mMboxFile.fileName() << "' FileError:"
              << d->mMboxFile.error();
     return false;
   }
 
   return true;
 }
 
-QByteArray MBox::mboxMessageSeparator(const QByteArray &msg)
+QByteArray MBox::mboxMessageSeparator( const QByteArray &msg )
 {
   KMime::Message mail;
-  mail.setHead(KMime::CRLFtoLF(msg));
+  mail.setHead( KMime::CRLFtoLF( msg ) );
   mail.parse();
 
   QByteArray seperator = "From ";
 
-  KMime::Headers::From *from = mail.from(false);
-  if (!from || from->addresses().isEmpty())
+  KMime::Headers::From *from = mail.from( false );
+  if ( !from || from->addresses().isEmpty() )
     seperator += "unknown@unknown.invalid";
   else
     seperator += from->addresses().first() + " ";
 
   KMime::Headers::Date *date = mail.date(false);
   if (!date || date->isEmpty())
-    seperator += QDateTime::currentDateTime().toString(Qt::TextDate).toUtf8() + '\n';
+    seperator += QDateTime::currentDateTime().toString( Qt::TextDate ).toUtf8() + '\n';
   else
     seperator += date->as7BitString(false) + '\n';
 
   return seperator;
 }
 
 #define STRDIM(x) (sizeof(x)/sizeof(*x)-1)
 
-QByteArray MBox::escapeFrom(const QByteArray &str)
+QByteArray MBox::escapeFrom( const QByteArray &str )
 {
   const unsigned int strLen = str.length();
-  if ( strLen <= STRDIM("From ") )
+  if ( strLen <= STRDIM( "From " ) )
     return str;
 
   // worst case: \nFrom_\nFrom_\nFrom_... => grows to 7/6
-  QByteArray result(int( strLen + 5 ) / 6 * 7 + 1, '\0');
+  QByteArray result( int( strLen + 5 ) / 6 * 7 + 1, '\0');
 
   const char * s = str.data();
-  const char * const e = s + strLen - STRDIM("From ");
+  const char * const e = s + strLen - STRDIM( "From ");
   char * d = result.data();
 
   bool onlyAnglesAfterLF = false; // dont' match ^From_
   while ( s < e ) {
     switch ( *s ) {
     case '\n':
       onlyAnglesAfterLF = true;
       break;
     case '>':
       break;
     case 'F':
       if ( onlyAnglesAfterLF && qstrncmp( s+1, "rom ", STRDIM("rom ") ) == 0 )
         *d++ = '>';
       // fall through
     default:
       onlyAnglesAfterLF = false;
       break;
     }
     *d++ = *s++;
   }
   while ( s < str.data() + strLen )
     *d++ = *s++;
 
   result.truncate( d - result.data() );
   return result;
 }
 
 // performs (\n|^)>{n}From_ -> \1>{n-1}From_ conversion
-void MBox::unescapeFrom(char* str, size_t strLen)
+void MBox::unescapeFrom( char* str, size_t strLen )
 {
-  if (!str)
+  if ( !str )
     return;
   if ( strLen <= STRDIM(">From ") )
     return;
 
   // yes, *d++ = *s++ is a no-op as long as d == s (until after the
   // first >From_), but writes are cheap compared to reads and the
   // data is already in the cache from the read, so special-casing
   // might even be slower...
   const char * s = str;
   char * d = str;
-  const char * const e = str + strLen - STRDIM(">From ");
+  const char * const e = str + strLen - STRDIM( ">From ");
 
   while ( s < e ) {
     if ( *s == '\n' && *(s+1) == '>' ) { // we can do the lookahead, since e is 6 chars from the end!
       *d++ = *s++;  // == '\n'
       *d++ = *s++;  // == '>'
       while ( s < e && *s == '>' )
         *d++ = *s++;
-      if ( qstrncmp( s, "From ", STRDIM("From ") ) == 0 )
+      if ( qstrncmp( s, "From ", STRDIM( "From ") ) == 0 )
         --d;
     }
     *d++ = *s++; // yes, s might be e here, but e is not the end :-)
   }
   // copy the rest:
   while ( s < str + strLen )
     *d++ = *s++;
   if ( d < s ) // only NUL-terminate if it's shorter
     *d = 0;
 }
 #undef STRDIM
diff --git a/kmbox/mbox.h b/kmbox/mbox.h
index 3731f4f47..184cd0751 100644
--- a/kmbox/mbox.h
+++ b/kmbox/mbox.h
@@ -1,207 +1,207 @@
 /*
     Copyright (c) 2009 Bertjan Broeksema <b.broeksema@kdemail.net>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     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., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #ifndef MBOX_H
 #define MBOX_H
 
 #include <boost/shared_ptr.hpp>
 #include <kmime/kmime_message.h>
 #include <QtCore/QSet>
 #include <QtCore/QString>
 
 #include "mbox_export.h"
 
 typedef QPair<quint64, quint64> MsgInfo; // QPair<offset, size>
 typedef boost::shared_ptr<KMime::Message> MessagePtr;
 
 class MBOX_EXPORT MBox
 {
   public:
     enum LockType {
       ProcmailLockfile,
       MuttDotlock,
       MuttDotlockPrivileged,
       None
     };
 
   public:
     MBox();
 
     /**
      * Unlocks the file if it is still open.
      */
     ~MBox();
 
     /**
      * Appends @param entry to the MBox. Returns the offset in the file
      * where the added message starts or -1 if the entry was not added (e.g.
      * when it doesn't contain data). Entries are only added after a call to
      * load( const QString& ). The returned offset is <em>only</em> valid for
      * that particular file.
      *
      * @param entry The message to append to the mbox.
      * @return the offset of the entry in the file or -1 if the entry was not
      *         added.
      */
     qint64 appendEntry( const MessagePtr &entry );
 
     /**
      * Retrieve MsgInfo objects for all emails from the file except the
      * @param deleteItems. The @param deletedItems should be a list of file
      * offsets of messages which are deleted.
      *
      * Each MsgInfo object contains the offset and the size of the messages in
      * the file which are not marked as deleted.
      *
      * Note: One <em>must</em> call open() before calling this method.
      */
-    QList<MsgInfo> entryList(const QSet<quint64> &deletedItems = QSet<quint64>()) const;
+    QList<MsgInfo> entryList( const QSet<quint64> &deletedItems = QSet<quint64>() ) const;
 
     /**
      * Loads a mbox on disk  into the current mbox. Messages already present are
      * *not* preserved. This method does not load the full messages into memory
      * but only the offsets of the messages and their sizes. If the file
      * currently is locked this method will do nothing and return false.
      * Appended messages that are not written yet will get lost.
      *
      * @param fileName the name of the mbox on disk.
      * @return true, if successful, false on error.
      *
      * @see save( const QString & )
      */
     bool load( const QString &fileName );
 
     /**
      * Locks the mbox file using the configured lock method. This can be used
      * for consecutive calls to readEntry and readEntryHeaders. Calling lock()
      * before these calls prevents the mbox file being locked for every call.
      *
      * @return true if locked successful, false on error.
      *
      * @see setLockType( LockType ), unlock()
      */
     bool lock();
 
     /**
      * Removes all messages at given offsets from the current reference file
      * (i.e. the file that is loaded with load( const QString & ) or the file
      * from the last save( const QString & ) call if that was not the same file).
      * This method will first check if all lines at the offsets are actually
      * seperator lines if this is not the no message will be deleted to prevent
      * corruption.
      *
      * @param deletedItems Offsets of the messages that should be removed from
      *                     the file.
      *
      * @return true if all offsets refer to a mbox seperator line and a file was
      *         loaded, false otherewhise. In the latter the physical file has
      *         not changed.
      */
     bool purge( const QSet<quint64> &deletedItems );
 
     /**
      * Reads the entire message from the file at given @param offset. If the
      * mbox file is not locked this method will lock the file before reading and
      * unlock it after reading. If the file already is locked, it will not
      * unlock the file after reading the entry.
      *
      * @param offset The start position of the entry in the mbox file.
      * @return Message at given offset or 0 if the the file could not be locked
      *         or the offset > fileSize.
      *
      * @see lock(), unlock()
      */
     KMime::Message *readEntry( quint64 offset );
 
     /**
      * Reads the headers of the message at given @param offset. If the
      * mbox file is not locked this method will lock the file before reading and
      * unlock it after reading. If the file already is locked, it will not
      * unlock the file after reading the entry.
      *
      * @param offset The start position of the entry in the mbox file.
      * @return QByteArray containing the raw Entry data.
      *
      * @see lock(), unlock()
      */
-    QByteArray readEntryHeaders(quint64 offset);
+    QByteArray readEntryHeaders( quint64 offset );
 
 
     /**
      * Writes the mbox to disk. If the fileName is empty only appended messages
      * will be written to the file that was passed to load( const QString & ).
      * Otherwise the contents of the file that was loaded with load is copied to
      * @p fileName first.
      *
      * @param fileName the name of the file
      * @return true if the save was successful; false otherwise.
      *
      * @see load( const QString & )
      */
     bool save( const QString &fileName = QString() );
 
     /**
      * Sets the locktype that should be used for locking the mbox file. If the
      * new LockType cannot be used (e.g. the lockfile executable could not be
      * found) the LockType will not be changed.
      *
      * This method will not do anything if the mbox obeject is currently locked
      * to make sure that it doesn't leave a locked file for one of the lockfile
      * / mutt_dotlock methods.
      */
-    bool setLockType(LockType ltype);
+    bool setLockType( LockType ltype );
 
     /**
      * Sets the lockfile that should be used by the procmail or the KDE lock
      * file method. If this method is not called and one of the before mentioned
      * lock methods is used the name of the lock file will be equal to
      * MBOXFILENAME.lock.
      */
-    void setLockFile(const QString &lockFile);
+    void setLockFile( const QString &lockFile );
 
     /**
      * Unlock the mbox file.
      *
      * @return true if the unlock was successful, false otherwise.
      *
      * @see lock()
      */
     bool unlock();
 
   private:
     bool open();
 
-    static QByteArray escapeFrom(const QByteArray &msg);
+    static QByteArray escapeFrom( const QByteArray &msg );
 
     /**
      * Generates a mbox message sperator line for given message.
      */
-    static QByteArray mboxMessageSeparator(const QByteArray &msg);
+    static QByteArray mboxMessageSeparator( const QByteArray &msg );
 
     /**
      * Unescapes the raw message read from the file.
      */
-    static void unescapeFrom(char *msg, size_t size);
+    static void unescapeFrom( char *msg, size_t size );
 
   private:
     class Private;
     Private *d;
 };
 
 #endif // MBOX_H