Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 4373 insertions, 0 deletions

diff --git a/kmail/kmmessage.cpp b/kmail/kmmessage.cpp
new file mode 100644
index 000000000..9c006b685
--- /dev/null
+++ b/kmail/kmmessage.cpp
@@ -0,0 +1,4373 @@
+// -*- mode: C++; c-file-style: "gnu" -*-
+// kmmessage.cpp
+
+// if you do not want GUI elements in here then set ALLOW_GUI to 0.
+#include <config.h>
+// needed temporarily until KMime is replacing the partNode helper class:
+#include "partNode.h"
+
+
+#define ALLOW_GUI 1
+#include "kmkernel.h"
+#include "kmmessage.h"
+#include "mailinglist-magic.h"
+#include "messageproperty.h"
+using KMail::MessageProperty;
+#include "objecttreeparser.h"
+using KMail::ObjectTreeParser;
+#include "kmfolderindex.h"
+#include "undostack.h"
+#include "kmversion.h"
+#include "headerstrategy.h"
+#include "globalsettings.h"
+using KMail::HeaderStrategy;
+#include "kmaddrbook.h"
+#include "kcursorsaver.h"
+#include "templateparser.h"
+
+#include <libkpimidentities/identity.h>
+#include <libkpimidentities/identitymanager.h>
+#include <libemailfunctions/email.h>
+
+#include <kasciistringtools.h>
+
+#include <kpgpblock.h>
+#include <kaddrbook.h>
+
+#include <kapplication.h>
+#include <kglobalsettings.h>
+#include <kdebug.h>
+#include <kconfig.h>
+#include <khtml_part.h>
+#include <kuser.h>
+#include <kidna.h>
+#include <kasciistricmp.h>
+
+#include <qcursor.h>
+#include <qtextcodec.h>
+#include <qmessagebox.h>
+#include <kmime_util.h>
+#include <kmime_charfreq.h>
+
+#include <kmime_header_parsing.h>
+using KMime::HeaderParsing::parseAddressList;
+using namespace KMime::Types;
+
+#include <mimelib/body.h>
+#include <mimelib/field.h>
+#include <mimelib/mimepp.h>
+#include <mimelib/string.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <time.h>
+#include <klocale.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "util.h"
+
+#if ALLOW_GUI
+#include <kmessagebox.h>
+#endif
+
+using namespace KMime;
+
+static DwString emptyString("");
+
+// Values that are set from the config file with KMMessage::readConfig()
+static QString sReplyLanguage, sReplyStr, sReplyAllStr, sIndentPrefixStr;
+static bool sSmartQuote,
+  sWordWrap;
+static int sWrapCol;
+static QStringList sPrefCharsets;
+
+QString KMMessage::sForwardStr;
+const HeaderStrategy * KMMessage::sHeaderStrategy = HeaderStrategy::rich();
+//helper
+static void applyHeadersToMessagePart( DwHeaders& headers, KMMessagePart* aPart );
+
+QValueList<KMMessage*> KMMessage::sPendingDeletes;
+
+//-----------------------------------------------------------------------------
+KMMessage::KMMessage(DwMessage* aMsg)
+  : KMMsgBase()
+{
+  init( aMsg );
+  // aMsg might need assembly
+  mNeedsAssembly = true;
+}
+
+//-----------------------------------------------------------------------------
+KMMessage::KMMessage(KMFolder* parent): KMMsgBase(parent)
+{
+  init();
+}
+
+
+//-----------------------------------------------------------------------------
+KMMessage::KMMessage(KMMsgInfo& msgInfo): KMMsgBase()
+{
+  init();
+  // now overwrite a few from the msgInfo
+  mMsgSize = msgInfo.msgSize();
+  mFolderOffset = msgInfo.folderOffset();
+  mStatus = msgInfo.status();
+  mEncryptionState = msgInfo.encryptionState();
+  mSignatureState = msgInfo.signatureState();
+  mMDNSentState = msgInfo.mdnSentState();
+  mDate = msgInfo.date();
+  mFileName = msgInfo.fileName();
+  KMMsgBase::assign(&msgInfo);
+}
+
+
+//-----------------------------------------------------------------------------
+KMMessage::KMMessage(const KMMessage& other) :
+    KMMsgBase( other ),
+    ISubject(),
+    mMsg(0)
+{
+  init(); // to be safe
+  assign( other );
+}
+
+void KMMessage::init( DwMessage* aMsg )
+{
+  mNeedsAssembly = false;
+  if ( aMsg ) {
+    mMsg = aMsg;
+  } else {
+    mMsg = new DwMessage;
+  }
+  mOverrideCodec = 0;
+  mDecodeHTML = false;
+  mComplete = true;
+  mReadyToShow = true;
+  mMsgSize = 0;
+  mMsgLength = 0;
+  mFolderOffset = 0;
+  mStatus  = KMMsgStatusNew;
+  mEncryptionState = KMMsgEncryptionStateUnknown;
+  mSignatureState = KMMsgSignatureStateUnknown;
+  mMDNSentState = KMMsgMDNStateUnknown;
+  mDate    = 0;
+  mUnencryptedMsg = 0;
+  mLastUpdated = 0;
+  mCursorPos = 0;
+  mMsgInfo = 0;
+  mIsParsed = false;
+}
+
+void KMMessage::assign( const KMMessage& other )
+{
+  MessageProperty::forget( this );
+  delete mMsg;
+  delete mUnencryptedMsg;
+
+  mNeedsAssembly = true;//other.mNeedsAssembly;
+  if( other.mMsg )
+    mMsg = new DwMessage( *(other.mMsg) );
+  else
+    mMsg = 0;
+  mOverrideCodec = other.mOverrideCodec;
+  mDecodeHTML = other.mDecodeHTML;
+  mMsgSize = other.mMsgSize;
+  mMsgLength = other.mMsgLength;
+  mFolderOffset = other.mFolderOffset;
+  mStatus  = other.mStatus;
+  mEncryptionState = other.mEncryptionState;
+  mSignatureState = other.mSignatureState;
+  mMDNSentState = other.mMDNSentState;
+  mIsParsed = other.mIsParsed;
+  mDate    = other.mDate;
+  if( other.hasUnencryptedMsg() )
+    mUnencryptedMsg = new KMMessage( *other.unencryptedMsg() );
+  else
+    mUnencryptedMsg = 0;
+  setDrafts( other.drafts() );
+  setTemplates( other.templates() );
+  //mFileName = ""; // we might not want to copy the other messages filename (?)
+  //KMMsgBase::assign( &other );
+}
+
+//-----------------------------------------------------------------------------
+KMMessage::~KMMessage()
+{
+  delete mMsgInfo;
+  delete mMsg;
+  kmkernel->undoStack()->msgDestroyed( this );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setReferences(const QCString& aStr)
+{
+  if (!aStr) return;
+  mMsg->Headers().References().FromString(aStr);
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::id() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasMessageId())
+    return KMail::Util::CString( header.MessageId().AsString() );
+  else
+    return "";
+}
+
+
+//-----------------------------------------------------------------------------
+//WARNING: This method updates the memory resident cache of serial numbers
+//WARNING: held in MessageProperty, but it does not update the persistent
+//WARNING: store of serial numbers on the file system that is managed by
+//WARNING: KMMsgDict
+void KMMessage::setMsgSerNum(unsigned long newMsgSerNum)
+{
+  MessageProperty::setSerialCache( this, newMsgSerNum );
+}
+
+
+//-----------------------------------------------------------------------------
+bool KMMessage::isMessage() const
+{
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+bool KMMessage::transferInProgress() const
+{
+  return MessageProperty::transferInProgress( getMsgSerNum() );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setTransferInProgress(bool value, bool force)
+{
+  MessageProperty::setTransferInProgress( getMsgSerNum(), value, force );
+  if ( !transferInProgress() && sPendingDeletes.contains( this ) ) {
+    sPendingDeletes.remove( this );
+    if ( parent() ) {
+      int idx = parent()->find( this );
+      if ( idx > 0 ) {
+        parent()->removeMsg( idx );
+      }
+    }
+  }
+}
+
+
+
+bool KMMessage::isUrgent() const {
+  return headerField( "Priority" ).contains( "urgent", false )
+    || headerField( "X-Priority" ).startsWith( "2" );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setUnencryptedMsg( KMMessage* unencrypted )
+{
+  delete mUnencryptedMsg;
+  mUnencryptedMsg = unencrypted;
+}
+
+//-----------------------------------------------------------------------------
+//FIXME: move to libemailfunctions
+KPIM::EmailParseResult KMMessage::isValidEmailAddressList( const QString& aStr,
+                                                           QString& brokenAddress )
+{
+  if ( aStr.isEmpty() ) {
+     return KPIM::AddressEmpty;
+  }
+
+  QStringList list = KPIM::splitEmailAddrList( aStr );
+  for( QStringList::const_iterator it = list.begin(); it != list.end(); ++it ) {
+    KPIM::EmailParseResult errorCode = KPIM::isValidEmailAddress( *it );
+      if ( errorCode != KPIM::AddressOk ) {
+      brokenAddress = ( *it );
+      return errorCode;
+    }
+  }
+  return KPIM::AddressOk;
+}
+
+//-----------------------------------------------------------------------------
+const DwString& KMMessage::asDwString() const
+{
+  if (mNeedsAssembly)
+  {
+    mNeedsAssembly = false;
+    mMsg->Assemble();
+  }
+  return mMsg->AsString();
+}
+
+//-----------------------------------------------------------------------------
+const DwMessage* KMMessage::asDwMessage()
+{
+  if (mNeedsAssembly)
+  {
+    mNeedsAssembly = false;
+    mMsg->Assemble();
+  }
+  return mMsg;
+}
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::asString() const {
+  return KMail::Util::CString( asDwString() );
+}
+
+
+QByteArray KMMessage::asSendableString() const
+{
+  KMMessage msg( new DwMessage( *this->mMsg ) );
+  msg.removePrivateHeaderFields();
+  msg.removeHeaderField("Bcc");
+  return KMail::Util::ByteArray( msg.asDwString() ); // and another copy again!
+}
+
+QCString KMMessage::headerAsSendableString() const
+{
+  KMMessage msg( new DwMessage( *this->mMsg ) );
+  msg.removePrivateHeaderFields();
+  msg.removeHeaderField("Bcc");
+  return msg.headerAsString().latin1();
+}
+
+void KMMessage::removePrivateHeaderFields() {
+  removeHeaderField("Status");
+  removeHeaderField("X-Status");
+  removeHeaderField("X-KMail-EncryptionState");
+  removeHeaderField("X-KMail-SignatureState");
+  removeHeaderField("X-KMail-MDN-Sent");
+  removeHeaderField("X-KMail-Transport");
+  removeHeaderField("X-KMail-Identity");
+  removeHeaderField("X-KMail-Fcc");
+  removeHeaderField("X-KMail-Redirect-From");
+  removeHeaderField("X-KMail-Link-Message");
+  removeHeaderField("X-KMail-Link-Type");
+  removeHeaderField( "X-KMail-Markup" );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setStatusFields()
+{
+  char str[2] = { 0, 0 };
+
+  setHeaderField("Status", status() & KMMsgStatusNew ? "R" : "RO");
+  setHeaderField("X-Status", statusToStr(status()));
+
+  str[0] = (char)encryptionState();
+  setHeaderField("X-KMail-EncryptionState", str);
+
+  str[0] = (char)signatureState();
+  //kdDebug(5006) << "Setting SignatureState header field to " << str[0] << endl;
+  setHeaderField("X-KMail-SignatureState", str);
+
+  str[0] = static_cast<char>( mdnSentState() );
+  setHeaderField("X-KMail-MDN-Sent", str);
+
+  // We better do the assembling ourselves now to prevent the
+  // mimelib from changing the message *body*.  (khz, 10.8.2002)
+  mNeedsAssembly = false;
+  mMsg->Headers().Assemble();
+  mMsg->Assemble( mMsg->Headers(),
+                  mMsg->Body() );
+}
+
+
+//----------------------------------------------------------------------------
+QString KMMessage::headerAsString() const
+{
+  DwHeaders& header = mMsg->Headers();
+  header.Assemble();
+  if ( header.AsString().empty() )
+    return QString::null;
+  return QString::fromLatin1( header.AsString().c_str() );
+}
+
+
+//-----------------------------------------------------------------------------
+DwMediaType& KMMessage::dwContentType()
+{
+  return mMsg->Headers().ContentType();
+}
+
+void KMMessage::fromByteArray( const QByteArray & ba, bool setStatus ) {
+  return fromDwString( DwString( ba.data(), ba.size() ), setStatus );
+}
+
+void KMMessage::fromString( const QCString & str, bool aSetStatus ) {
+  return fromDwString( KMail::Util::dwString( str ), aSetStatus );
+}
+
+void KMMessage::fromDwString(const DwString& str, bool aSetStatus)
+{
+  delete mMsg;
+  mMsg = new DwMessage;
+  mMsg->FromString( str );
+  mMsg->Parse();
+
+  if (aSetStatus) {
+    setStatus(headerField("Status").latin1(), headerField("X-Status").latin1());
+    setEncryptionStateChar( headerField("X-KMail-EncryptionState").at(0) );
+    setSignatureStateChar(  headerField("X-KMail-SignatureState").at(0) );
+    setMDNSentState( static_cast<KMMsgMDNSentState>( headerField("X-KMail-MDN-Sent").at(0).latin1() ) );
+  }
+  if (attachmentState() == KMMsgAttachmentUnknown && readyToShow())
+    updateAttachmentState();
+
+  mNeedsAssembly = false;
+  mDate = date();
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::formatString(const QString& aStr) const
+{
+  QString result, str;
+  QChar ch;
+  uint j;
+
+  if (aStr.isEmpty())
+    return aStr;
+
+  unsigned int strLength(aStr.length());
+  for (uint i=0; i<strLength;) {
+    ch = aStr[i++];
+    if (ch == '%') {
+      ch = aStr[i++];
+      switch ((char)ch) {
+      case 'D':
+	/* I'm not too sure about this change. Is it not possible
+	   to have a long form of the date used? I don't
+	   like this change to a short XX/XX/YY date format.
+	   At least not for the default. -sanders */
+	result += KMime::DateFormatter::formatDate( KMime::DateFormatter::Localized,
+						    date(), sReplyLanguage, false );
+        break;
+      case 'e':
+        result += from();
+        break;
+      case 'F':
+        result += fromStrip();
+        break;
+      case 'f':
+		{
+        str = fromStrip();
+
+        for (j=0; str[j]>' '; j++)
+          ;
+		unsigned int strLength(str.length());
+        for (; j < strLength && str[j] <= ' '; j++)
+          ;
+        result += str[0];
+        if (str[j]>' ')
+          result += str[j];
+        else
+          if (str[1]>' ')
+            result += str[1];
+		}
+        break;
+      case 'T':
+        result += toStrip();
+        break;
+      case 't':
+        result += to();
+        break;
+      case 'C':
+        result += ccStrip();
+        break;
+      case 'c':
+        result += cc();
+        break;
+      case 'S':
+        result += subject();
+        break;
+      case '_':
+        result += ' ';
+        break;
+      case 'L':
+        result += "\n";
+        break;
+      case '%':
+        result += '%';
+        break;
+      default:
+        result += '%';
+        result += ch;
+        break;
+      }
+    } else
+      result += ch;
+  }
+  return result;
+}
+
+static void removeTrailingSpace( QString &line )
+{
+   int i = line.length()-1;
+   while( (i >= 0) && ((line[i] == ' ') || (line[i] == '\t')))
+      i--;
+   line.truncate( i+1);
+}
+
+static QString splitLine( QString &line)
+{
+    removeTrailingSpace( line );
+    int i = 0;
+    int j = -1;
+    int l = line.length();
+
+    // TODO: Replace tabs with spaces first.
+
+    while(i < l)
+    {
+       QChar c = line[i];
+       if ((c == '>') || (c == ':') || (c == '|'))
+          j = i+1;
+       else if ((c != ' ') && (c != '\t'))
+          break;
+       i++;
+    }
+
+    if ( j <= 0 )
+    {
+       return "";
+    }
+    if ( i == l )
+    {
+       QString result = line.left(j);
+       line = QString::null;
+       return result;
+    }
+
+    QString result = line.left(j);
+    line = line.mid(j);
+    return result;
+}
+
+static QString flowText(QString &text, const QString& indent, int maxLength)
+{
+   maxLength--;
+   if (text.isEmpty())
+   {
+      return indent+"<NULL>\n";
+   }
+   QString result;
+   while (1)
+   {
+      int i;
+      if ((int) text.length() > maxLength)
+      {
+         i = maxLength;
+         while( (i >= 0) && (text[i] != ' '))
+            i--;
+         if (i <= 0)
+         {
+            // Couldn't break before maxLength.
+            i = maxLength;
+//            while( (i < (int) text.length()) && (text[i] != ' '))
+//               i++;
+         }
+      }
+      else
+      {
+         i = text.length();
+      }
+
+      QString line = text.left(i);
+      if (i < (int) text.length())
+         text = text.mid(i);
+      else
+         text = QString::null;
+
+      result += indent + line + '\n';
+
+      if (text.isEmpty())
+         return result;
+   }
+}
+
+static bool flushPart(QString &msg, QStringList &part,
+                      const QString &indent, int maxLength)
+{
+   maxLength -= indent.length();
+   if (maxLength < 20) maxLength = 20;
+
+   // Remove empty lines at end of quote
+   while ((part.begin() != part.end()) && part.last().isEmpty())
+   {
+      part.remove(part.fromLast());
+   }
+
+   QString text;
+   for(QStringList::Iterator it2 = part.begin();
+       it2 != part.end();
+       it2++)
+   {
+      QString line = (*it2);
+
+      if (line.isEmpty())
+      {
+         if (!text.isEmpty())
+            msg += flowText(text, indent, maxLength);
+         msg += indent + '\n';
+      }
+      else
+      {
+         if (text.isEmpty())
+            text = line;
+         else
+            text += ' '+line.stripWhiteSpace();
+
+         if (((int) text.length() < maxLength) || ((int) line.length() < (maxLength-10)))
+            msg += flowText(text, indent, maxLength);
+      }
+   }
+   if (!text.isEmpty())
+      msg += flowText(text, indent, maxLength);
+
+   bool appendEmptyLine = true;
+   if (!part.count())
+     appendEmptyLine = false;
+
+   part.clear();
+   return appendEmptyLine;
+}
+
+static QString stripSignature( const QString & msg, bool clearSigned ) {
+  if ( clearSigned )
+    return msg.left( msg.findRev( QRegExp( "\n--\\s?\n" ) ) );
+  else
+    return msg.left( msg.findRev( "\n-- \n" ) );
+}
+
+QString KMMessage::smartQuote( const QString & msg, int maxLineLength )
+{
+  QStringList part;
+  QString oldIndent;
+  bool firstPart = true;
+
+
+  const QStringList lines = QStringList::split('\n', msg, true);
+
+  QString result;
+  for(QStringList::const_iterator it = lines.begin();
+      it != lines.end();
+      ++it)
+  {
+     QString line = *it;
+
+     const QString indent = splitLine( line );
+
+     if ( line.isEmpty())
+     {
+        if (!firstPart)
+           part.append(QString::null);
+        continue;
+     };
+
+     if (firstPart)
+     {
+        oldIndent = indent;
+        firstPart = false;
+     }
+
+     if (oldIndent != indent)
+     {
+        QString fromLine;
+        // Search if the last non-blank line could be "From" line
+        if (part.count() && (oldIndent.length() < indent.length()))
+        {
+           QStringList::Iterator it2 = part.fromLast();
+           while( (it2 != part.end()) && (*it2).isEmpty())
+             --it2;
+
+           if ((it2 != part.end()) && ((*it2).endsWith(":")))
+           {
+              fromLine = oldIndent + (*it2) + '\n';
+              part.remove(it2);
+           }
+        }
+        if (flushPart( result, part, oldIndent, maxLineLength))
+        {
+           if (oldIndent.length() > indent.length())
+              result += indent + '\n';
+           else
+              result += oldIndent + '\n';
+        }
+        if (!fromLine.isEmpty())
+        {
+           result += fromLine;
+        }
+        oldIndent = indent;
+     }
+     part.append(line);
+  }
+  flushPart( result, part, oldIndent, maxLineLength);
+  return result;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::parseTextStringFromDwPart( partNode * root,
+                                           QCString& parsedString,
+                                           const QTextCodec*& codec,
+                                           bool& isHTML ) const
+{
+  if ( !root ) return;
+
+  isHTML = false;
+  // initialy parse the complete message to decrypt any encrypted parts
+  {
+    ObjectTreeParser otp( 0, 0, true, false, true );
+    otp.parseObjectTree( root );
+  }
+  partNode * curNode = root->findType( DwMime::kTypeText,
+                               DwMime::kSubtypeUnknown,
+                               true,
+                               false );
+  kdDebug(5006) << "\n\n======= KMMessage::parseTextStringFromDwPart()   -    "
+                << ( curNode ? "text part found!\n" : "sorry, no text node!\n" ) << endl;
+  if( curNode ) {
+    isHTML = DwMime::kSubtypeHtml == curNode->subType();
+    // now parse the TEXT message part we want to quote
+    ObjectTreeParser otp( 0, 0, true, false, true );
+    otp.parseObjectTree( curNode );
+    parsedString = otp.rawReplyString();
+    codec = curNode->msgPart().codec();
+  }
+}
+
+//-----------------------------------------------------------------------------
+
+QString KMMessage::asPlainText( bool aStripSignature, bool allowDecryption ) const {
+  QCString parsedString;
+  bool isHTML = false;
+  const QTextCodec * codec = 0;
+
+  partNode * root = partNode::fromMessage( this );
+  if ( !root ) return QString::null;
+  parseTextStringFromDwPart( root, parsedString, codec, isHTML );
+  delete root;
+
+  if ( mOverrideCodec || !codec )
+    codec = this->codec();
+
+  if ( parsedString.isEmpty() )
+    return QString::null;
+
+  bool clearSigned = false;
+  QString result;
+
+  // decrypt
+  if ( allowDecryption ) {
+    QPtrList<Kpgp::Block> pgpBlocks;
+    QStrList nonPgpBlocks;
+    if ( Kpgp::Module::prepareMessageForDecryption( parsedString,
+						    pgpBlocks,
+						    nonPgpBlocks ) ) {
+      // Only decrypt/strip off the signature if there is only one OpenPGP
+      // block in the message
+      if ( pgpBlocks.count() == 1 ) {
+	Kpgp::Block * block = pgpBlocks.first();
+	if ( block->type() == Kpgp::PgpMessageBlock ||
+	     block->type() == Kpgp::ClearsignedBlock ) {
+	  if ( block->type() == Kpgp::PgpMessageBlock ) {
+	    // try to decrypt this OpenPGP block
+	    block->decrypt();
+	  } else {
+	    // strip off the signature
+	    block->verify();
+	    clearSigned = true;
+	  }
+
+	  result = codec->toUnicode( nonPgpBlocks.first() )
+	         + codec->toUnicode( block->text() )
+	         + codec->toUnicode( nonPgpBlocks.last() );
+	}
+      }
+    }
+  }
+
+  if ( result.isEmpty() ) {
+    result = codec->toUnicode( parsedString );
+    if ( result.isEmpty() )
+      return result;
+  }
+
+  // html -> plaintext conversion, if necessary:
+  if ( isHTML && mDecodeHTML ) {
+    KHTMLPart htmlPart;
+    htmlPart.setOnlyLocalReferences( true );
+    htmlPart.setMetaRefreshEnabled( false );
+    htmlPart.setPluginsEnabled( false );
+    htmlPart.setJScriptEnabled( false );
+    htmlPart.setJavaEnabled( false );
+    htmlPart.begin();
+    htmlPart.write( result );
+    htmlPart.end();
+    htmlPart.selectAll();
+    result = htmlPart.selectedText();
+  }
+
+  // strip the signature (footer):
+  if ( aStripSignature )
+    return stripSignature( result, clearSigned );
+  else
+    return result;
+}
+
+QString KMMessage::asQuotedString( const QString& aHeaderStr,
+				   const QString& aIndentStr,
+				   const QString& selection /* = QString::null */,
+				   bool aStripSignature /* = true */,
+				   bool allowDecryption /* = true */) const
+{
+  QString content = selection.isEmpty() ?
+    asPlainText( aStripSignature, allowDecryption ) : selection ;
+
+  // Remove blank lines at the beginning:
+  const int firstNonWS = content.find( QRegExp( "\\S" ) );
+  const int lineStart = content.findRev( '\n', firstNonWS );
+  if ( lineStart >= 0 )
+    content.remove( 0, static_cast<unsigned int>( lineStart ) );
+
+  const QString indentStr = formatString( aIndentStr );
+
+  content.replace( '\n', '\n' + indentStr );
+  content.prepend( indentStr );
+  content += '\n';
+
+  const QString headerStr = formatString( aHeaderStr );
+  if ( sSmartQuote && sWordWrap )
+    return headerStr + smartQuote( content, sWrapCol );
+  return headerStr + content;
+}
+
+//-----------------------------------------------------------------------------
+KMMessage* KMMessage::createReply( KMail::ReplyStrategy replyStrategy,
+                                   QString selection /* = QString::null */,
+                                   bool noQuote /* = false */,
+                                   bool allowDecryption /* = true */,
+                                   bool selectionIsBody /* = false */,
+                                   const QString &tmpl /* = QString::null */ )
+{
+  KMMessage* msg = new KMMessage;
+  QString str, replyStr, mailingListStr, replyToStr, toStr;
+  QStringList mailingListAddresses;
+  QCString refStr, headerName;
+  bool replyAll = true;
+
+  msg->initFromMessage(this);
+
+  MailingList::name(this, headerName, mailingListStr);
+  replyToStr = replyTo();
+
+  msg->setCharset("utf-8");
+
+  // determine the mailing list posting address
+  if ( parent() && parent()->isMailingListEnabled() &&
+       !parent()->mailingListPostAddress().isEmpty() ) {
+    mailingListAddresses << parent()->mailingListPostAddress();
+  }
+  if ( headerField("List-Post").find( "mailto:", 0, false ) != -1 ) {
+    QString listPost = headerField("List-Post");
+    QRegExp rx( "<mailto:([^@>]+)@([^>]+)>", false );
+    if ( rx.search( listPost, 0 ) != -1 ) // matched
+      mailingListAddresses << rx.cap(1) + '@' + rx.cap(2);
+  }
+
+  // use the "On ... Joe User wrote:" header by default
+  replyStr = sReplyAllStr;
+
+  switch( replyStrategy ) {
+  case KMail::ReplySmart : {
+    if ( !headerField( "Mail-Followup-To" ).isEmpty() ) {
+      toStr = headerField( "Mail-Followup-To" );
+    }
+    else if ( !replyToStr.isEmpty() ) {
+      // assume a Reply-To header mangling mailing list
+      toStr = replyToStr;
+    }
+    else if ( !mailingListAddresses.isEmpty() ) {
+      toStr = mailingListAddresses[0];
+    }
+    else {
+      // doesn't seem to be a mailing list, reply to From: address
+      toStr = from();
+      replyStr = sReplyStr; // reply to author, so use "On ... you wrote:"
+      replyAll = false;
+    }
+    // strip all my addresses from the list of recipients
+    QStringList recipients = KPIM::splitEmailAddrList( toStr );
+    toStr = stripMyAddressesFromAddressList( recipients ).join(", ");
+    // ... unless the list contains only my addresses (reply to self)
+    if ( toStr.isEmpty() && !recipients.isEmpty() )
+      toStr = recipients[0];
+
+    break;
+  }
+  case KMail::ReplyList : {
+    if ( !headerField( "Mail-Followup-To" ).isEmpty() ) {
+      toStr = headerField( "Mail-Followup-To" );
+    }
+    else if ( !mailingListAddresses.isEmpty() ) {
+      toStr = mailingListAddresses[0];
+    }
+    else if ( !replyToStr.isEmpty() ) {
+      // assume a Reply-To header mangling mailing list
+      toStr = replyToStr;
+    }
+    // strip all my addresses from the list of recipients
+    QStringList recipients = KPIM::splitEmailAddrList( toStr );
+    toStr = stripMyAddressesFromAddressList( recipients ).join(", ");
+
+    break;
+  }
+  case KMail::ReplyAll : {
+    QStringList recipients;
+    QStringList ccRecipients;
+
+    // add addresses from the Reply-To header to the list of recipients
+    if( !replyToStr.isEmpty() ) {
+      recipients += KPIM::splitEmailAddrList( replyToStr );
+      // strip all possible mailing list addresses from the list of Reply-To
+      // addresses
+      for ( QStringList::const_iterator it = mailingListAddresses.begin();
+            it != mailingListAddresses.end();
+            ++it ) {
+        recipients = stripAddressFromAddressList( *it, recipients );
+      }
+    }
+
+    if ( !mailingListAddresses.isEmpty() ) {
+      // this is a mailing list message
+      if ( recipients.isEmpty() && !from().isEmpty() ) {
+        // The sender didn't set a Reply-to address, so we add the From
+        // address to the list of CC recipients.
+        ccRecipients += from();
+        kdDebug(5006) << "Added " << from() << " to the list of CC recipients"
+                      << endl;
+      }
+      // if it is a mailing list, add the posting address
+      recipients.prepend( mailingListAddresses[0] );
+    }
+    else {
+      // this is a normal message
+      if ( recipients.isEmpty() && !from().isEmpty() ) {
+        // in case of replying to a normal message only then add the From
+        // address to the list of recipients if there was no Reply-to address
+        recipients += from();
+        kdDebug(5006) << "Added " << from() << " to the list of recipients"
+                      << endl;
+      }
+    }
+
+    // strip all my addresses from the list of recipients
+    toStr = stripMyAddressesFromAddressList( recipients ).join(", ");
+
+    // merge To header and CC header into a list of CC recipients
+    if( !cc().isEmpty() || !to().isEmpty() ) {
+      QStringList list;
+      if (!to().isEmpty())
+        list += KPIM::splitEmailAddrList(to());
+      if (!cc().isEmpty())
+        list += KPIM::splitEmailAddrList(cc());
+      for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
+        if(    !addressIsInAddressList( *it, recipients )
+            && !addressIsInAddressList( *it, ccRecipients ) ) {
+          ccRecipients += *it;
+          kdDebug(5006) << "Added " << *it << " to the list of CC recipients"
+                        << endl;
+        }
+      }
+    }
+
+    if ( !ccRecipients.isEmpty() ) {
+      // strip all my addresses from the list of CC recipients
+      ccRecipients = stripMyAddressesFromAddressList( ccRecipients );
+
+      // in case of a reply to self toStr might be empty. if that's the case
+      // then propagate a cc recipient to To: (if there is any).
+      if ( toStr.isEmpty() && !ccRecipients.isEmpty() ) {
+        toStr = ccRecipients[0];
+        ccRecipients.pop_front();
+      }
+
+      msg->setCc( ccRecipients.join(", ") );
+    }
+
+    if ( toStr.isEmpty() && !recipients.isEmpty() ) {
+      // reply to self without other recipients
+      toStr = recipients[0];
+    }
+    break;
+  }
+  case KMail::ReplyAuthor : {
+    if ( !replyToStr.isEmpty() ) {
+      QStringList recipients = KPIM::splitEmailAddrList( replyToStr );
+      // strip the mailing list post address from the list of Reply-To
+      // addresses since we want to reply in private
+      for ( QStringList::const_iterator it = mailingListAddresses.begin();
+            it != mailingListAddresses.end();
+            ++it ) {
+        recipients = stripAddressFromAddressList( *it, recipients );
+      }
+      if ( !recipients.isEmpty() ) {
+        toStr = recipients.join(", ");
+      }
+      else {
+        // there was only the mailing list post address in the Reply-To header,
+        // so use the From address instead
+        toStr = from();
+      }
+    }
+    else if ( !from().isEmpty() ) {
+      toStr = from();
+    }
+    replyStr = sReplyStr; // reply to author, so use "On ... you wrote:"
+    replyAll = false;
+    break;
+  }
+  case KMail::ReplyNone : {
+    // the addressees will be set by the caller
+  }
+  }
+
+  msg->setTo(toStr);
+
+  refStr = getRefStr();
+  if (!refStr.isEmpty())
+    msg->setReferences(refStr);
+  //In-Reply-To = original msg-id
+  msg->setReplyToId(msgId());
+
+//   if (!noQuote) {
+//     if( selectionIsBody ){
+//       QCString cStr = selection.latin1();
+//       msg->setBody( cStr );
+//     }else{
+//       msg->setBody(asQuotedString(replyStr + "\n", sIndentPrefixStr, selection,
+// 				  sSmartQuote, allowDecryption).utf8());
+//     }
+//   }
+
+  msg->setSubject( replySubject() );
+
+  TemplateParser parser( msg, (replyAll ? TemplateParser::ReplyAll : TemplateParser::Reply),
+    selection, sSmartQuote, noQuote, allowDecryption, selectionIsBody );
+  if ( !tmpl.isEmpty() ) {
+    parser.process( tmpl, this );
+  } else {
+    parser.process( this );
+  }
+
+  // setStatus(KMMsgStatusReplied);
+  msg->link(this, KMMsgStatusReplied);
+
+  if ( parent() && parent()->putRepliesInSameFolder() )
+    msg->setFcc( parent()->idString() );
+
+  // replies to an encrypted message should be encrypted as well
+  if ( encryptionState() == KMMsgPartiallyEncrypted ||
+       encryptionState() == KMMsgFullyEncrypted ) {
+    msg->setEncryptionState( KMMsgFullyEncrypted );
+  }
+
+  return msg;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::getRefStr() const
+{
+  QCString firstRef, lastRef, refStr, retRefStr;
+  int i, j;
+
+  refStr = headerField("References").stripWhiteSpace().latin1();
+
+  if (refStr.isEmpty())
+    return headerField("Message-Id").latin1();
+
+  i = refStr.find('<');
+  j = refStr.find('>');
+  firstRef = refStr.mid(i, j-i+1);
+  if (!firstRef.isEmpty())
+    retRefStr = firstRef + ' ';
+
+  i = refStr.findRev('<');
+  j = refStr.findRev('>');
+
+  lastRef = refStr.mid(i, j-i+1);
+  if (!lastRef.isEmpty() && lastRef != firstRef)
+    retRefStr += lastRef + ' ';
+
+  retRefStr += headerField("Message-Id").latin1();
+  return retRefStr;
+}
+
+
+KMMessage* KMMessage::createRedirect( const QString &toStr )
+{
+  // copy the message 1:1
+  KMMessage* msg = new KMMessage( new DwMessage( *this->mMsg ) );
+  KMMessagePart msgPart;
+
+  uint id = 0;
+  QString strId = msg->headerField( "X-KMail-Identity" ).stripWhiteSpace();
+  if ( !strId.isEmpty())
+    id = strId.toUInt();
+  const KPIM::Identity & ident =
+    kmkernel->identityManager()->identityForUoidOrDefault( id );
+
+  // X-KMail-Redirect-From: content
+  QString strByWayOf = QString("%1 (by way of %2 <%3>)")
+    .arg( from() )
+    .arg( ident.fullName() )
+    .arg( ident.emailAddr() );
+
+  // Resent-From: content
+  QString strFrom = QString("%1 <%2>")
+    .arg( ident.fullName() )
+    .arg( ident.emailAddr() );
+
+  // format the current date to be used in Resent-Date:
+  QString origDate = msg->headerField( "Date" );
+  msg->setDateToday();
+  QString newDate = msg->headerField( "Date" );
+  // make sure the Date: header is valid
+  if ( origDate.isEmpty() )
+    msg->removeHeaderField( "Date" );
+  else
+    msg->setHeaderField( "Date", origDate );
+
+  // prepend Resent-*: headers (c.f. RFC2822 3.6.6)
+  msg->setHeaderField( "Resent-Message-ID", generateMessageId( msg->sender() ),
+                       Structured, true);
+  msg->setHeaderField( "Resent-Date", newDate, Structured, true );
+  msg->setHeaderField( "Resent-To",   toStr,   Address, true );
+  msg->setHeaderField( "Resent-From", strFrom, Address, true );
+
+  msg->setHeaderField( "X-KMail-Redirect-From", strByWayOf );
+  msg->setHeaderField( "X-KMail-Recipients", toStr, Address );
+
+  msg->link(this, KMMsgStatusForwarded);
+
+  return msg;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::createForwardBody()
+{
+  QString s;
+  QCString str;
+
+  if (sHeaderStrategy == HeaderStrategy::all()) {
+    s = "\n\n----------  " + sForwardStr + "  ----------\n\n";
+    s += headerAsString();
+    str = asQuotedString(s, "", QString::null, false, false).utf8();
+    str += "\n-------------------------------------------------------\n";
+  } else {
+    s = "\n\n----------  " + sForwardStr + "  ----------\n\n";
+    s += "Subject: " + subject() + "\n";
+    s += "Date: "
+         + KMime::DateFormatter::formatDate( KMime::DateFormatter::Localized,
+                                             date(), sReplyLanguage, false )
+         + "\n";
+    s += "From: " + from() + "\n";
+    s += "To: " + to() + "\n";
+    if (!cc().isEmpty()) s += "Cc: " + cc() + "\n";
+    s += "\n";
+    str = asQuotedString(s, "", QString::null, false, false).utf8();
+    str += "\n-------------------------------------------------------\n";
+  }
+
+  return str;
+}
+
+void KMMessage::sanitizeHeaders( const QStringList& whiteList )
+{
+   // Strip out all headers apart from the content description and other
+   // whitelisted ones, because we don't want to inherit them.
+   DwHeaders& header = mMsg->Headers();
+   DwField* field = header.FirstField();
+   DwField* nextField;
+   while (field)
+   {
+     nextField = field->Next();
+     if ( field->FieldNameStr().find( "ontent" ) == DwString::npos
+             && !whiteList.contains( QString::fromLatin1( field->FieldNameStr().c_str() ) ) )
+       header.RemoveField(field);
+     field = nextField;
+   }
+   mMsg->Assemble();
+}
+
+//-----------------------------------------------------------------------------
+KMMessage* KMMessage::createForward( const QString &tmpl /* = QString::null */ )
+{
+  KMMessage* msg = new KMMessage();
+  QString id;
+
+  // If this is a multipart mail or if the main part is only the text part,
+  // Make an identical copy of the mail, minus headers, so attachments are
+  // preserved
+  if ( type() == DwMime::kTypeMultipart ||
+     ( type() == DwMime::kTypeText && subtype() == DwMime::kSubtypePlain ) ) {
+    // ## slow, we could probably use: delete msg->mMsg; msg->mMsg = new DwMessage( this->mMsg );
+    msg->fromDwString( this->asDwString() );
+    // remember the type and subtype, initFromMessage sets the contents type to
+    // text/plain, via initHeader, for unclear reasons
+    const int type = msg->type();
+    const int subtype = msg->subtype();
+
+    msg->sanitizeHeaders();
+
+    // strip blacklisted parts
+    QStringList blacklist = GlobalSettings::self()->mimetypesToStripWhenInlineForwarding();
+    for ( QStringList::Iterator it = blacklist.begin(); it != blacklist.end(); ++it ) {
+      QString entry = (*it);
+      int sep = entry.find( '/' );
+      QCString type = entry.left( sep ).latin1();
+      QCString subtype = entry.mid( sep+1 ).latin1();
+      kdDebug( 5006 ) << "Looking for blacklisted type: " << type << "/" << subtype << endl;
+      while ( DwBodyPart * part = msg->findDwBodyPart( type, subtype ) ) {
+        msg->mMsg->Body().RemoveBodyPart( part );
+      }
+    }
+    msg->mMsg->Assemble();
+
+    msg->initFromMessage( this );
+    //restore type
+    msg->setType( type );
+    msg->setSubtype( subtype );
+  } else if( type() == DwMime::kTypeText && subtype() == DwMime::kSubtypeHtml ) {
+    // This is non-multipart html mail. Let`s make it text/plain and allow
+    // template parser do the hard job.
+    msg->initFromMessage( this );
+    msg->setType( DwMime::kTypeText );
+    msg->setSubtype( DwMime::kSubtypeHtml );
+    msg->mNeedsAssembly = true;
+    msg->cleanupHeader();
+  } else {
+    // This is a non-multipart, non-text mail (e.g. text/calendar). Construct
+    // a multipart/mixed mail and add the original body as an attachment.
+    msg->initFromMessage( this );
+    msg->removeHeaderField("Content-Type");
+    msg->removeHeaderField("Content-Transfer-Encoding");
+    // Modify the ContentType directly (replaces setAutomaticFields(true))
+    DwHeaders & header = msg->mMsg->Headers();
+    header.MimeVersion().FromString("1.0");
+    DwMediaType & contentType = msg->dwContentType();
+    contentType.SetType( DwMime::kTypeMultipart );
+    contentType.SetSubtype( DwMime::kSubtypeMixed );
+    contentType.CreateBoundary(0);
+    contentType.Assemble();
+
+    // empty text part
+    KMMessagePart msgPart;
+    bodyPart( 0, &msgPart );
+    msg->addBodyPart(&msgPart);
+    // the old contents of the mail
+    KMMessagePart secondPart;
+    secondPart.setType( type() );
+    secondPart.setSubtype( subtype() );
+    secondPart.setBody( mMsg->Body().AsString() );
+    // use the headers of the original mail
+    applyHeadersToMessagePart( mMsg->Headers(), &secondPart );
+    msg->addBodyPart(&secondPart);
+    msg->mNeedsAssembly = true;
+    msg->cleanupHeader();
+  }
+  // QString st = QString::fromUtf8(createForwardBody());
+
+  msg->setSubject( forwardSubject() );
+
+  TemplateParser parser( msg, TemplateParser::Forward,
+    asPlainText( false, false ),
+    false, false, false, false);
+  if ( !tmpl.isEmpty() ) {
+    parser.process( tmpl, this );
+  } else {
+    parser.process( this );
+  }
+
+  // QCString encoding = autoDetectCharset(charset(), sPrefCharsets, msg->body());
+  // if (encoding.isEmpty()) encoding = "utf-8";
+  // msg->setCharset(encoding);
+
+  // force utf-8
+  // msg->setCharset( "utf-8" );
+
+  msg->link(this, KMMsgStatusForwarded);
+  return msg;
+}
+
+static const struct {
+  const char * dontAskAgainID;
+  bool         canDeny;
+  const char * text;
+} mdnMessageBoxes[] = {
+  { "mdnNormalAsk", true,
+    I18N_NOOP("This message contains a request to return a notification "
+	      "about your reception of the message.\n"
+	      "You can either ignore the request or let KMail send a "
+	      "\"denied\" or normal response.") },
+  { "mdnUnknownOption", false,
+    I18N_NOOP("This message contains a request to send a notification "
+	      "about your reception of the message.\n"
+	      "It contains a processing instruction that is marked as "
+	      "\"required\", but which is unknown to KMail.\n"
+	      "You can either ignore the request or let KMail send a "
+	      "\"failed\" response.") },
+  { "mdnMultipleAddressesInReceiptTo", true,
+    I18N_NOOP("This message contains a request to send a notification "
+	      "about your reception of the message,\n"
+	      "but it is requested to send the notification to more "
+	      "than one address.\n"
+	      "You can either ignore the request or let KMail send a "
+	      "\"denied\" or normal response.") },
+  { "mdnReturnPathEmpty", true,
+    I18N_NOOP("This message contains a request to send a notification "
+	      "about your reception of the message,\n"
+	      "but there is no return-path set.\n"
+	      "You can either ignore the request or let KMail send a "
+	      "\"denied\" or normal response.") },
+  { "mdnReturnPathNotInReceiptTo", true,
+    I18N_NOOP("This message contains a request to send a notification "
+	      "about your reception of the message,\n"
+	      "but the return-path address differs from the address "
+	      "the notification was requested to be sent to.\n"
+	      "You can either ignore the request or let KMail send a "
+	      "\"denied\" or normal response.") },
+};
+
+static const int numMdnMessageBoxes
+      = sizeof mdnMessageBoxes / sizeof *mdnMessageBoxes;
+
+
+static int requestAdviceOnMDN( const char * what ) {
+  for ( int i = 0 ; i < numMdnMessageBoxes ; ++i )
+    if ( !qstrcmp( what, mdnMessageBoxes[i].dontAskAgainID ) )
+      if ( mdnMessageBoxes[i].canDeny ) {
+	const KCursorSaver saver( QCursor::ArrowCursor );
+	int answer = QMessageBox::information( 0,
+			 i18n("Message Disposition Notification Request"),
+			 i18n( mdnMessageBoxes[i].text ),
+			 i18n("&Ignore"), i18n("Send \"&denied\""), i18n("&Send") );
+	return answer ? answer + 1 : 0 ; // map to "mode" in createMDN
+      } else {
+	const KCursorSaver saver( QCursor::ArrowCursor );
+	int answer = QMessageBox::information( 0,
+			 i18n("Message Disposition Notification Request"),
+			 i18n( mdnMessageBoxes[i].text ),
+			 i18n("&Ignore"), i18n("&Send") );
+	return answer ? answer + 2 : 0 ; // map to "mode" in createMDN
+      }
+  kdWarning(5006) << "didn't find data for message box \""
+		  << what << "\"" << endl;
+  return 0;
+}
+
+KMMessage* KMMessage::createMDN( MDN::ActionMode a,
+				 MDN::DispositionType d,
+				 bool allowGUI,
+				 QValueList<MDN::DispositionModifier> m )
+{
+  // RFC 2298: At most one MDN may be issued on behalf of each
+  // particular recipient by their user agent.  That is, once an MDN
+  // has been issued on behalf of a recipient, no further MDNs may be
+  // issued on behalf of that recipient, even if another disposition
+  // is performed on the message.
+//#define MDN_DEBUG 1
+#ifndef MDN_DEBUG
+  if ( mdnSentState() != KMMsgMDNStateUnknown &&
+       mdnSentState() != KMMsgMDNNone )
+    return 0;
+#else
+  char st[2]; st[0] = (char)mdnSentState(); st[1] = 0;
+  kdDebug(5006) << "mdnSentState() == '" << st << "'" << endl;
+#endif
+
+  // RFC 2298: An MDN MUST NOT be generated in response to an MDN.
+  if ( findDwBodyPart( DwMime::kTypeMessage,
+		       DwMime::kSubtypeDispositionNotification ) ) {
+    setMDNSentState( KMMsgMDNIgnore );
+    return 0;
+  }
+
+  // extract where to send to:
+  QString receiptTo = headerField("Disposition-Notification-To");
+  if ( receiptTo.stripWhiteSpace().isEmpty() ) return 0;
+  receiptTo.remove( '\n' );
+
+
+  MDN::SendingMode s = MDN::SentAutomatically; // set to manual if asked user
+  QString special; // fill in case of error, warning or failure
+  KConfigGroup mdnConfig( KMKernel::config(), "MDN" );
+
+  // default:
+  int mode = mdnConfig.readNumEntry( "default-policy", 0 );
+  if ( !mode || mode < 0 || mode > 3 ) {
+    // early out for ignore:
+    setMDNSentState( KMMsgMDNIgnore );
+    return 0;
+  }
+
+  // RFC 2298: An importance of "required" indicates that
+  // interpretation of the parameter is necessary for proper
+  // generation of an MDN in response to this request.  If a UA does
+  // not understand the meaning of the parameter, it MUST NOT generate
+  // an MDN with any disposition type other than "failed" in response
+  // to the request.
+  QString notificationOptions = headerField("Disposition-Notification-Options");
+  if ( notificationOptions.contains( "required", false ) ) {
+    // ### hacky; should parse...
+    // There is a required option that we don't understand. We need to
+    // ask the user what we should do:
+    if ( !allowGUI ) return 0; // don't setMDNSentState here!
+    mode = requestAdviceOnMDN( "mdnUnknownOption" );
+    s = MDN::SentManually;
+
+    special = i18n("Header \"Disposition-Notification-Options\" contained "
+		   "required, but unknown parameter");
+    d = MDN::Failed;
+    m.clear(); // clear modifiers
+  }
+
+  // RFC 2298: [ Confirmation from the user SHOULD be obtained (or no
+  // MDN sent) ] if there is more than one distinct address in the
+  // Disposition-Notification-To header.
+  kdDebug(5006) << "KPIM::splitEmailAddrList(receiptTo): "
+	    << KPIM::splitEmailAddrList(receiptTo).join("\n") << endl;
+  if ( KPIM::splitEmailAddrList(receiptTo).count() > 1 ) {
+    if ( !allowGUI ) return 0; // don't setMDNSentState here!
+    mode = requestAdviceOnMDN( "mdnMultipleAddressesInReceiptTo" );
+    s = MDN::SentManually;
+  }
+
+  // RFC 2298: MDNs SHOULD NOT be sent automatically if the address in
+  // the Disposition-Notification-To header differs from the address
+  // in the Return-Path header. [...] Confirmation from the user
+  // SHOULD be obtained (or no MDN sent) if there is no Return-Path
+  // header in the message [...]
+  AddrSpecList returnPathList = extractAddrSpecs("Return-Path");
+  QString returnPath = returnPathList.isEmpty() ? QString::null
+    : returnPathList.front().localPart + '@' + returnPathList.front().domain ;
+  kdDebug(5006) << "clean return path: " << returnPath << endl;
+  if ( returnPath.isEmpty() || !receiptTo.contains( returnPath, false ) ) {
+    if ( !allowGUI ) return 0; // don't setMDNSentState here!
+    mode = requestAdviceOnMDN( returnPath.isEmpty() ?
+			       "mdnReturnPathEmpty" :
+			       "mdnReturnPathNotInReceiptTo" );
+    s = MDN::SentManually;
+  }
+
+  if ( a != KMime::MDN::AutomaticAction ) {
+    //TODO: only ingore user settings for AutomaticAction if requested
+    if ( mode == 1 ) { // ask
+      if ( !allowGUI ) return 0; // don't setMDNSentState here!
+      mode = requestAdviceOnMDN( "mdnNormalAsk" );
+      s = MDN::SentManually; // asked user
+    }
+
+    switch ( mode ) {
+      case 0: // ignore:
+        setMDNSentState( KMMsgMDNIgnore );
+        return 0;
+      default:
+      case 1:
+        kdFatal(5006) << "KMMessage::createMDN(): The \"ask\" mode should "
+                                                  << "never appear here!" << endl;
+        break;
+      case 2: // deny
+        d = MDN::Denied;
+        m.clear();
+        break;
+      case 3:
+        break;
+    }
+  }
+
+
+  // extract where to send from:
+  QString finalRecipient = kmkernel->identityManager()
+    ->identityForUoidOrDefault( identityUoid() ).fullEmailAddr();
+
+  //
+  // Generate message:
+  //
+
+  KMMessage * receipt = new KMMessage();
+  receipt->initFromMessage( this );
+  receipt->removeHeaderField("Content-Type");
+  receipt->removeHeaderField("Content-Transfer-Encoding");
+  // Modify the ContentType directly (replaces setAutomaticFields(true))
+  DwHeaders & header = receipt->mMsg->Headers();
+  header.MimeVersion().FromString("1.0");
+  DwMediaType & contentType = receipt->dwContentType();
+  contentType.SetType( DwMime::kTypeMultipart );
+  contentType.SetSubtype( DwMime::kSubtypeReport );
+  contentType.CreateBoundary(0);
+  receipt->mNeedsAssembly = true;
+  receipt->setContentTypeParam( "report-type", "disposition-notification" );
+
+  QString description = replaceHeadersInString( MDN::descriptionFor( d, m ) );
+
+  // text/plain part:
+  KMMessagePart firstMsgPart;
+  firstMsgPart.setTypeStr( "text" );
+  firstMsgPart.setSubtypeStr( "plain" );
+  firstMsgPart.setBodyFromUnicode( description );
+  receipt->addBodyPart( &firstMsgPart );
+
+  // message/disposition-notification part:
+  KMMessagePart secondMsgPart;
+  secondMsgPart.setType( DwMime::kTypeMessage );
+  secondMsgPart.setSubtype( DwMime::kSubtypeDispositionNotification );
+  //secondMsgPart.setCharset( "us-ascii" );
+  //secondMsgPart.setCteStr( "7bit" );
+  secondMsgPart.setBodyEncoded( MDN::dispositionNotificationBodyContent(
+	                    finalRecipient,
+			    rawHeaderField("Original-Recipient"),
+			    id(), /* Message-ID */
+			    d, a, s, m, special ) );
+  receipt->addBodyPart( &secondMsgPart );
+
+  // message/rfc822 or text/rfc822-headers body part:
+  int num = mdnConfig.readNumEntry( "quote-message", 0 );
+  if ( num < 0 || num > 2 ) num = 0;
+  MDN::ReturnContent returnContent = static_cast<MDN::ReturnContent>( num );
+
+  KMMessagePart thirdMsgPart;
+  switch ( returnContent ) {
+  case MDN::All:
+    thirdMsgPart.setTypeStr( "message" );
+    thirdMsgPart.setSubtypeStr( "rfc822" );
+    thirdMsgPart.setBody( asSendableString() );
+    receipt->addBodyPart( &thirdMsgPart );
+    break;
+  case MDN::HeadersOnly:
+    thirdMsgPart.setTypeStr( "text" );
+    thirdMsgPart.setSubtypeStr( "rfc822-headers" );
+    thirdMsgPart.setBody( headerAsSendableString() );
+    receipt->addBodyPart( &thirdMsgPart );
+    break;
+  case MDN::Nothing:
+  default:
+    break;
+  };
+
+  receipt->setTo( receiptTo );
+  receipt->setSubject( "Message Disposition Notification" );
+  receipt->setReplyToId( msgId() );
+  receipt->setReferences( getRefStr() );
+
+  receipt->cleanupHeader();
+
+  kdDebug(5006) << "final message:\n" + receipt->asString() << endl;
+
+  //
+  // Set "MDN sent" status:
+  //
+  KMMsgMDNSentState state = KMMsgMDNStateUnknown;
+  switch ( d ) {
+  case MDN::Displayed:   state = KMMsgMDNDisplayed;  break;
+  case MDN::Deleted:     state = KMMsgMDNDeleted;    break;
+  case MDN::Dispatched:  state = KMMsgMDNDispatched; break;
+  case MDN::Processed:   state = KMMsgMDNProcessed;  break;
+  case MDN::Denied:      state = KMMsgMDNDenied;     break;
+  case MDN::Failed:      state = KMMsgMDNFailed;     break;
+  };
+  setMDNSentState( state );
+
+  return receipt;
+}
+
+QString KMMessage::replaceHeadersInString( const QString & s ) const {
+  QString result = s;
+  QRegExp rx( "\\$\\{([a-z0-9-]+)\\}", false );
+  Q_ASSERT( rx.isValid() );
+
+  QRegExp rxDate( "\\$\\{date\\}" );
+  Q_ASSERT( rxDate.isValid() );
+
+  QString sDate = KMime::DateFormatter::formatDate(
+                      KMime::DateFormatter::Localized, date() );
+
+  int idx = 0;
+  if( ( idx = rxDate.search( result, idx ) ) != -1  ) {
+    result.replace( idx, rxDate.matchedLength(), sDate );
+  }
+
+  idx = 0;
+  while ( ( idx = rx.search( result, idx ) ) != -1 ) {
+    QString replacement = headerField( rx.cap(1).latin1() );
+    result.replace( idx, rx.matchedLength(), replacement );
+    idx += replacement.length();
+  }
+  return result;
+}
+
+KMMessage* KMMessage::createDeliveryReceipt() const
+{
+  QString str, receiptTo;
+  KMMessage *receipt;
+
+  receiptTo = headerField("Disposition-Notification-To");
+  if ( receiptTo.stripWhiteSpace().isEmpty() ) return 0;
+  receiptTo.remove( '\n' );
+
+  receipt = new KMMessage;
+  receipt->initFromMessage(this);
+  receipt->setTo(receiptTo);
+  receipt->setSubject(i18n("Receipt: ") + subject());
+
+  str  = "Your message was successfully delivered.";
+  str += "\n\n---------- Message header follows ----------\n";
+  str += headerAsString();
+  str += "--------------------------------------------\n";
+  // Conversion to latin1 is correct here as Mail headers should contain
+  // ascii only
+  receipt->setBody(str.latin1());
+  receipt->setAutomaticFields();
+
+  return receipt;
+}
+
+
+void KMMessage::applyIdentity( uint id )
+{
+  const KPIM::Identity & ident =
+    kmkernel->identityManager()->identityForUoidOrDefault( id );
+
+  if(ident.fullEmailAddr().isEmpty())
+    setFrom("");
+  else
+    setFrom(ident.fullEmailAddr());
+
+  if(ident.replyToAddr().isEmpty())
+    setReplyTo("");
+  else
+    setReplyTo(ident.replyToAddr());
+
+  if(ident.bcc().isEmpty())
+    setBcc("");
+  else
+    setBcc(ident.bcc());
+
+  if (ident.organization().isEmpty())
+    removeHeaderField("Organization");
+  else
+    setHeaderField("Organization", ident.organization());
+
+  if (ident.isDefault())
+    removeHeaderField("X-KMail-Identity");
+  else
+    setHeaderField("X-KMail-Identity", QString::number( ident.uoid() ));
+
+  if ( ident.transport().isEmpty() )
+    removeHeaderField( "X-KMail-Transport" );
+  else
+    setHeaderField( "X-KMail-Transport", ident.transport() );
+
+  if ( ident.fcc().isEmpty() )
+    setFcc( QString::null );
+  else
+    setFcc( ident.fcc() );
+
+  if ( ident.drafts().isEmpty() )
+    setDrafts( QString::null );
+  else
+    setDrafts( ident.drafts() );
+
+  if ( ident.templates().isEmpty() )
+    setTemplates( QString::null );
+  else
+    setTemplates( ident.templates() );
+
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::initHeader( uint id )
+{
+  applyIdentity( id );
+  setTo("");
+  setSubject("");
+  setDateToday();
+
+  setHeaderField("User-Agent", "KMail/" KMAIL_VERSION );
+  // This will allow to change Content-Type:
+  setHeaderField("Content-Type","text/plain");
+}
+
+uint KMMessage::identityUoid() const {
+  QString idString = headerField("X-KMail-Identity").stripWhiteSpace();
+  bool ok = false;
+  int id = idString.toUInt( &ok );
+
+  if ( !ok || id == 0 )
+    id = kmkernel->identityManager()->identityForAddress( to() + ", " + cc() ).uoid();
+  if ( id == 0 && parent() )
+    id = parent()->identity();
+
+  return id;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::initFromMessage(const KMMessage *msg, bool idHeaders)
+{
+  uint id = msg->identityUoid();
+
+  if ( idHeaders ) initHeader(id);
+  else setHeaderField("X-KMail-Identity", QString::number(id));
+  if (!msg->headerField("X-KMail-Transport").isEmpty())
+    setHeaderField("X-KMail-Transport", msg->headerField("X-KMail-Transport"));
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::cleanupHeader()
+{
+  DwHeaders& header = mMsg->Headers();
+  DwField* field = header.FirstField();
+  DwField* nextField;
+
+  if (mNeedsAssembly) mMsg->Assemble();
+  mNeedsAssembly = false;
+
+  while (field)
+  {
+    nextField = field->Next();
+    if (field->FieldBody()->AsString().empty())
+    {
+      header.RemoveField(field);
+      mNeedsAssembly = true;
+    }
+    field = nextField;
+  }
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setAutomaticFields(bool aIsMulti)
+{
+  DwHeaders& header = mMsg->Headers();
+  header.MimeVersion().FromString("1.0");
+
+  if (aIsMulti || numBodyParts() > 1)
+  {
+    // Set the type to 'Multipart' and the subtype to 'Mixed'
+    DwMediaType& contentType = dwContentType();
+    contentType.SetType(   DwMime::kTypeMultipart);
+    contentType.SetSubtype(DwMime::kSubtypeMixed );
+
+    // Create a random printable string and set it as the boundary parameter
+    contentType.CreateBoundary(0);
+  }
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::dateStr() const
+{
+  KConfigGroup general( KMKernel::config(), "General" );
+  DwHeaders& header = mMsg->Headers();
+  time_t unixTime;
+
+  if (!header.HasDate()) return "";
+  unixTime = header.Date().AsUnixTime();
+
+  //kdDebug(5006)<<"####  Date = "<<header.Date().AsString().c_str()<<endl;
+
+  return KMime::DateFormatter::formatDate(
+      static_cast<KMime::DateFormatter::FormatType>(general.readNumEntry( "dateFormat", KMime::DateFormatter::Fancy )),
+      unixTime, general.readEntry( "customDateFormat" ));
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::dateShortStr() const
+{
+  DwHeaders& header = mMsg->Headers();
+  time_t unixTime;
+
+  if (!header.HasDate()) return "";
+  unixTime = header.Date().AsUnixTime();
+
+  QCString result = ctime(&unixTime);
+  int len = result.length();
+  if (result[len-1]=='\n')
+    result.truncate(len-1);
+
+  return result;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::dateIsoStr() const
+{
+  DwHeaders& header = mMsg->Headers();
+  time_t unixTime;
+
+  if (!header.HasDate()) return "";
+  unixTime = header.Date().AsUnixTime();
+
+  char cstr[64];
+  strftime(cstr, 63, "%Y-%m-%d %H:%M:%S", localtime(&unixTime));
+  return QString(cstr);
+}
+
+
+//-----------------------------------------------------------------------------
+time_t KMMessage::date() const
+{
+  time_t res = ( time_t )-1;
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasDate())
+    res = header.Date().AsUnixTime();
+  return res;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setDateToday()
+{
+  struct timeval tval;
+  gettimeofday(&tval, 0);
+  setDate((time_t)tval.tv_sec);
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setDate(time_t aDate)
+{
+  mDate = aDate;
+  mMsg->Headers().Date().FromCalendarTime(aDate);
+  mMsg->Headers().Date().Assemble();
+  mNeedsAssembly = true;
+  mDirty = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setDate(const QCString& aStr)
+{
+  DwHeaders& header = mMsg->Headers();
+
+  header.Date().FromString(aStr);
+  header.Date().Parse();
+  mNeedsAssembly = true;
+  mDirty = true;
+
+  if (header.HasDate())
+    mDate = header.Date().AsUnixTime();
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::to() const
+{
+  // handle To same as Cc below, bug 80747
+  QValueList<QCString> rawHeaders = rawHeaderFields( "To" );
+  QStringList headers;
+  for ( QValueList<QCString>::Iterator it = rawHeaders.begin(); it != rawHeaders.end(); ++it ) {
+    headers << *it;
+  }
+  return KPIM::normalizeAddressesAndDecodeIDNs( headers.join( ", " ) );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setTo(const QString& aStr)
+{
+  setHeaderField( "To", aStr, Address );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::toStrip() const
+{
+  return stripEmailAddr( to() );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::replyTo() const
+{
+  return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("Reply-To") );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setReplyTo(const QString& aStr)
+{
+  setHeaderField( "Reply-To", aStr, Address );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setReplyTo(KMMessage* aMsg)
+{
+  setHeaderField( "Reply-To", aMsg->from(), Address );
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::cc() const
+{
+  // get the combined contents of all Cc headers (as workaround for invalid
+  // messages with multiple Cc headers)
+  QValueList<QCString> rawHeaders = rawHeaderFields( "Cc" );
+  QStringList headers;
+  for ( QValueList<QCString>::Iterator it = rawHeaders.begin(); it != rawHeaders.end(); ++it ) {
+    headers << *it;
+  }
+  return KPIM::normalizeAddressesAndDecodeIDNs( headers.join( ", " ) );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setCc(const QString& aStr)
+{
+  setHeaderField( "Cc", aStr, Address );
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::ccStrip() const
+{
+  return stripEmailAddr( cc() );
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::bcc() const
+{
+  return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("Bcc") );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBcc(const QString& aStr)
+{
+  setHeaderField( "Bcc", aStr, Address );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::fcc() const
+{
+  return headerField( "X-KMail-Fcc" );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setFcc( const QString &aStr )
+{
+  setHeaderField( "X-KMail-Fcc", aStr );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setDrafts( const QString &aStr )
+{
+  mDrafts = aStr;
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setTemplates( const QString &aStr )
+{
+  mTemplates = aStr;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::who() const
+{
+  if (mParent)
+    return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField(mParent->whoField().utf8()) );
+  return from();
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::from() const
+{
+  return KPIM::normalizeAddressesAndDecodeIDNs( rawHeaderField("From") );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setFrom(const QString& bStr)
+{
+  QString aStr = bStr;
+  if (aStr.isNull())
+    aStr = "";
+  setHeaderField( "From", aStr, Address );
+  mDirty = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::fromStrip() const
+{
+  return stripEmailAddr( from() );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::sender() const {
+  AddrSpecList asl = extractAddrSpecs( "Sender" );
+  if ( asl.empty() )
+    asl = extractAddrSpecs( "From" );
+  if ( asl.empty() )
+    return QString::null;
+  return asl.front().asString();
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::subject() const
+{
+  return headerField("Subject");
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setSubject(const QString& aStr)
+{
+  setHeaderField("Subject",aStr);
+  mDirty = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::xmark() const
+{
+  return headerField("X-KMail-Mark");
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setXMark(const QString& aStr)
+{
+  setHeaderField("X-KMail-Mark", aStr);
+  mDirty = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::replyToId() const
+{
+  int leftAngle, rightAngle;
+  QString replyTo, references;
+
+  replyTo = headerField("In-Reply-To");
+  // search the end of the (first) message id in the In-Reply-To header
+  rightAngle = replyTo.find( '>' );
+  if (rightAngle != -1)
+    replyTo.truncate( rightAngle + 1 );
+  // now search the start of the message id
+  leftAngle = replyTo.findRev( '<' );
+  if (leftAngle != -1)
+    replyTo = replyTo.mid( leftAngle );
+
+  // if we have found a good message id we can return immediately
+  // We ignore mangled In-Reply-To headers which are created by a
+  // misconfigured Mutt. They look like this <"from foo"@bar.baz>, i.e.
+  // they contain double quotes and spaces. We only check for '"'.
+  if (!replyTo.isEmpty() && (replyTo[0] == '<') &&
+      ( -1 == replyTo.find( '"' ) ) )
+    return replyTo;
+
+  references = headerField("References");
+  leftAngle = references.findRev( '<' );
+  if (leftAngle != -1)
+    references = references.mid( leftAngle );
+  rightAngle = references.find( '>' );
+  if (rightAngle != -1)
+    references.truncate( rightAngle + 1 );
+
+  // if we found a good message id in the References header return it
+  if (!references.isEmpty() && references[0] == '<')
+    return references;
+  // else return the broken message id we found in the In-Reply-To header
+  else
+    return replyTo;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::replyToIdMD5() const {
+  return base64EncodedMD5( replyToId() );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::references() const
+{
+  int leftAngle, rightAngle;
+  QString references = headerField( "References" );
+
+  // keep the last two entries for threading
+  leftAngle = references.findRev( '<' );
+  leftAngle = references.findRev( '<', leftAngle - 1 );
+  if( leftAngle != -1 )
+    references = references.mid( leftAngle );
+  rightAngle = references.findRev( '>' );
+  if( rightAngle != -1 )
+    references.truncate( rightAngle + 1 );
+
+  if( !references.isEmpty() && references[0] == '<' )
+    return references;
+  else
+    return QString::null;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::replyToAuxIdMD5() const
+{
+  QString result = references();
+  // references contains two items, use the first one
+  // (the second to last reference)
+  const int rightAngle = result.find( '>' );
+  if( rightAngle != -1 )
+    result.truncate( rightAngle + 1 );
+
+  return base64EncodedMD5( result );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::strippedSubjectMD5() const {
+  return base64EncodedMD5( stripOffPrefixes( subject() ), true /*utf8*/ );
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::subjectMD5() const {
+  return base64EncodedMD5( subject(), true /*utf8*/ );
+}
+
+//-----------------------------------------------------------------------------
+bool KMMessage::subjectIsPrefixed() const {
+  return subjectMD5() != strippedSubjectMD5();
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setReplyToId(const QString& aStr)
+{
+  setHeaderField("In-Reply-To", aStr);
+  mDirty = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::msgId() const
+{
+  QString msgId = headerField("Message-Id");
+
+  // search the end of the message id
+  const int rightAngle = msgId.find( '>' );
+  if (rightAngle != -1)
+    msgId.truncate( rightAngle + 1 );
+  // now search the start of the message id
+  const int leftAngle = msgId.findRev( '<' );
+  if (leftAngle != -1)
+    msgId = msgId.mid( leftAngle );
+  return msgId;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::msgIdMD5() const {
+  return base64EncodedMD5( msgId() );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setMsgId(const QString& aStr)
+{
+  setHeaderField("Message-Id", aStr);
+  mDirty = true;
+}
+
+//-----------------------------------------------------------------------------
+size_t KMMessage::msgSizeServer() const {
+  return headerField( "X-Length" ).toULong();
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setMsgSizeServer(size_t size)
+{
+  setHeaderField("X-Length", QCString().setNum(size));
+  mDirty = true;
+}
+
+//-----------------------------------------------------------------------------
+ulong KMMessage::UID() const {
+  return headerField( "X-UID" ).toULong();
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setUID(ulong uid)
+{
+  setHeaderField("X-UID", QCString().setNum(uid));
+  mDirty = true;
+}
+
+//-----------------------------------------------------------------------------
+AddressList KMMessage::splitAddrField( const QCString & str )
+{
+  AddressList result;
+  const char * scursor = str.begin();
+  if ( !scursor )
+    return AddressList();
+  const char * const send = str.begin() + str.length();
+  if ( !parseAddressList( scursor, send, result ) )
+    kdDebug(5006) << "Error in address splitting: parseAddressList returned false!"
+                  << endl;
+  return result;
+}
+
+AddressList KMMessage::headerAddrField( const QCString & aName ) const {
+  return KMMessage::splitAddrField( rawHeaderField( aName ) );
+}
+
+AddrSpecList KMMessage::extractAddrSpecs( const QCString & header ) const {
+  AddressList al = headerAddrField( header );
+  AddrSpecList result;
+  for ( AddressList::const_iterator ait = al.begin() ; ait != al.end() ; ++ait )
+    for ( MailboxList::const_iterator mit = (*ait).mailboxList.begin() ; mit != (*ait).mailboxList.end() ; ++mit )
+      result.push_back( (*mit).addrSpec );
+  return result;
+}
+
+QCString KMMessage::rawHeaderField( const QCString & name ) const {
+  if ( name.isEmpty() ) return QCString();
+
+  DwHeaders & header = mMsg->Headers();
+  DwField * field = header.FindField( name );
+
+  if ( !field ) return QCString();
+
+  return header.FieldBody( name.data() ).AsString().c_str();
+}
+
+QValueList<QCString> KMMessage::rawHeaderFields( const QCString& field ) const
+{
+  if ( field.isEmpty() || !mMsg->Headers().FindField( field ) )
+    return QValueList<QCString>();
+
+  std::vector<DwFieldBody*> v = mMsg->Headers().AllFieldBodies( field.data() );
+  QValueList<QCString> headerFields;
+  for ( uint i = 0; i < v.size(); ++i ) {
+    headerFields.append( v[i]->AsString().c_str() );
+  }
+
+  return headerFields;
+}
+
+QString KMMessage::headerField(const QCString& aName) const
+{
+  if ( aName.isEmpty() )
+    return QString::null;
+
+  if ( !mMsg->Headers().FindField( aName ) )
+    return QString::null;
+
+  return decodeRFC2047String( mMsg->Headers().FieldBody( aName.data() ).AsString().c_str(),
+                              charset() );
+
+}
+
+QStringList KMMessage::headerFields( const QCString& field ) const
+{
+  if ( field.isEmpty() || !mMsg->Headers().FindField( field ) )
+    return QStringList();
+
+  std::vector<DwFieldBody*> v = mMsg->Headers().AllFieldBodies( field.data() );
+  QStringList headerFields;
+  for ( uint i = 0; i < v.size(); ++i ) {
+    headerFields.append( decodeRFC2047String( v[i]->AsString().c_str(), charset() ) );
+  }
+
+  return headerFields;
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::removeHeaderField(const QCString& aName)
+{
+  DwHeaders & header = mMsg->Headers();
+  DwField * field = header.FindField(aName);
+  if (!field) return;
+
+  header.RemoveField(field);
+  mNeedsAssembly = true;
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::removeHeaderFields(const QCString& aName)
+{
+  DwHeaders & header = mMsg->Headers();
+  while ( DwField * field = header.FindField(aName) ) {
+    header.RemoveField(field);
+    mNeedsAssembly = true;
+  }
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setHeaderField( const QCString& aName, const QString& bValue,
+                                HeaderFieldType type, bool prepend )
+{
+#if 0
+  if ( type != Unstructured )
+    kdDebug(5006) << "KMMessage::setHeaderField( \"" << aName << "\", \""
+                << bValue << "\", " << type << " )" << endl;
+#endif
+  if (aName.isEmpty()) return;
+
+  DwHeaders& header = mMsg->Headers();
+
+  DwString str;
+  DwField* field;
+  QCString aValue;
+  if (!bValue.isEmpty())
+  {
+    QString value = bValue;
+    if ( type == Address )
+      value = KPIM::normalizeAddressesAndEncodeIDNs( value );
+#if 0
+    if ( type != Unstructured )
+      kdDebug(5006) << "value: \"" << value << "\"" << endl;
+#endif
+    QCString encoding = autoDetectCharset( charset(), sPrefCharsets, value );
+    if (encoding.isEmpty())
+       encoding = "utf-8";
+    aValue = encodeRFC2047String( value, encoding );
+#if 0
+    if ( type != Unstructured )
+      kdDebug(5006) << "aValue: \"" << aValue << "\"" << endl;
+#endif
+  }
+  str = aName;
+  if (str[str.length()-1] != ':') str += ": ";
+  else str += ' ';
+  if ( !aValue.isEmpty() )
+    str += aValue;
+  if (str[str.length()-1] != '\n') str += '\n';
+
+  field = new DwField(str, mMsg);
+  field->Parse();
+
+  if ( prepend )
+    header.AddFieldAt( 1, field );
+  else
+    header.AddOrReplaceField( field );
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::typeStr() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentType()) return header.ContentType().TypeStr().c_str();
+  else return "";
+}
+
+
+//-----------------------------------------------------------------------------
+int KMMessage::type() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentType()) return header.ContentType().Type();
+  else return DwMime::kTypeNull;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setTypeStr(const QCString& aStr)
+{
+  dwContentType().SetTypeStr(DwString(aStr));
+  dwContentType().Parse();
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setType(int aType)
+{
+  dwContentType().SetType(aType);
+  dwContentType().Assemble();
+  mNeedsAssembly = true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::subtypeStr() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentType()) return header.ContentType().SubtypeStr().c_str();
+  else return "";
+}
+
+
+//-----------------------------------------------------------------------------
+int KMMessage::subtype() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentType()) return header.ContentType().Subtype();
+  else return DwMime::kSubtypeNull;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setSubtypeStr(const QCString& aStr)
+{
+  dwContentType().SetSubtypeStr(DwString(aStr));
+  dwContentType().Parse();
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setSubtype(int aSubtype)
+{
+  dwContentType().SetSubtype(aSubtype);
+  dwContentType().Assemble();
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setDwMediaTypeParam( DwMediaType &mType,
+                                     const QCString& attr,
+                                     const QCString& val )
+{
+  mType.Parse();
+  DwParameter *param = mType.FirstParameter();
+  while(param) {
+    if (!kasciistricmp(param->Attribute().c_str(), attr))
+      break;
+    else
+      param = param->Next();
+  }
+  if (!param){
+    param = new DwParameter;
+    param->SetAttribute(DwString( attr ));
+    mType.AddParameter( param );
+  }
+  else
+    mType.SetModified();
+  param->SetValue(DwString( val ));
+  mType.Assemble();
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setContentTypeParam(const QCString& attr, const QCString& val)
+{
+  if (mNeedsAssembly) mMsg->Assemble();
+  mNeedsAssembly = false;
+  setDwMediaTypeParam( dwContentType(), attr, val );
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::contentTransferEncodingStr() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentTransferEncoding())
+    return header.ContentTransferEncoding().AsString().c_str();
+  else return "";
+}
+
+
+//-----------------------------------------------------------------------------
+int KMMessage::contentTransferEncoding() const
+{
+  DwHeaders& header = mMsg->Headers();
+  if (header.HasContentTransferEncoding())
+    return header.ContentTransferEncoding().AsEnum();
+  else return DwMime::kCteNull;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setContentTransferEncodingStr(const QCString& aStr)
+{
+  mMsg->Headers().ContentTransferEncoding().FromString(aStr);
+  mMsg->Headers().ContentTransferEncoding().Parse();
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setContentTransferEncoding(int aCte)
+{
+  mMsg->Headers().ContentTransferEncoding().FromEnum(aCte);
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+DwHeaders& KMMessage::headers() const
+{
+  return mMsg->Headers();
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setNeedsAssembly()
+{
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::body() const
+{
+  const DwString& body = mMsg->Body().AsString();
+  QCString str = KMail::Util::CString( body );
+  // Calls length() -> slow
+  //kdWarning( str.length() != body.length(), 5006 )
+  //  << "KMMessage::body(): body is binary but used as text!" << endl;
+  return str;
+}
+
+
+//-----------------------------------------------------------------------------
+QByteArray KMMessage::bodyDecodedBinary() const
+{
+  DwString dwstr;
+  const DwString& dwsrc = mMsg->Body().AsString();
+
+  switch (cte())
+  {
+  case DwMime::kCteBase64:
+    DwDecodeBase64(dwsrc, dwstr);
+    break;
+  case DwMime::kCteQuotedPrintable:
+    DwDecodeQuotedPrintable(dwsrc, dwstr);
+    break;
+  default:
+    dwstr = dwsrc;
+    break;
+  }
+
+  int len = dwstr.size();
+  QByteArray ba(len);
+  memcpy(ba.data(),dwstr.data(),len);
+  return ba;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::bodyDecoded() const
+{
+  DwString dwstr;
+  DwString dwsrc = mMsg->Body().AsString();
+
+  switch (cte())
+  {
+  case DwMime::kCteBase64:
+    DwDecodeBase64(dwsrc, dwstr);
+    break;
+  case DwMime::kCteQuotedPrintable:
+    DwDecodeQuotedPrintable(dwsrc, dwstr);
+    break;
+  default:
+    dwstr = dwsrc;
+    break;
+  }
+
+  return KMail::Util::CString( dwstr );
+
+  // Calling QCString::length() is slow
+  //QCString result = KMail::Util::CString( dwstr );
+  //kdWarning(result.length() != len, 5006)
+  //  << "KMMessage::bodyDecoded(): body is binary but used as text!" << endl;
+  //return result;
+}
+
+
+//-----------------------------------------------------------------------------
+QValueList<int> KMMessage::determineAllowedCtes( const CharFreq& cf,
+                                                 bool allow8Bit,
+                                                 bool willBeSigned )
+{
+  QValueList<int> allowedCtes;
+
+  switch ( cf.type() ) {
+  case CharFreq::SevenBitText:
+    allowedCtes << DwMime::kCte7bit;
+  case CharFreq::EightBitText:
+    if ( allow8Bit )
+      allowedCtes << DwMime::kCte8bit;
+  case CharFreq::SevenBitData:
+    if ( cf.printableRatio() > 5.0/6.0 ) {
+      // let n the length of data and p the number of printable chars.
+      // Then base64 \approx 4n/3; qp \approx p + 3(n-p)
+      // => qp < base64 iff p > 5n/6.
+      allowedCtes << DwMime::kCteQp;
+      allowedCtes << DwMime::kCteBase64;
+    } else {
+      allowedCtes << DwMime::kCteBase64;
+      allowedCtes << DwMime::kCteQp;
+    }
+    break;
+  case CharFreq::EightBitData:
+    allowedCtes << DwMime::kCteBase64;
+    break;
+  case CharFreq::None:
+  default:
+    // just nothing (avoid compiler warning)
+    ;
+  }
+
+  // In the following cases only QP and Base64 are allowed:
+  // - the buffer will be OpenPGP/MIME signed and it contains trailing
+  //   whitespace (cf. RFC 3156)
+  // - a line starts with "From "
+  if ( ( willBeSigned && cf.hasTrailingWhitespace() ) ||
+       cf.hasLeadingFrom() ) {
+    allowedCtes.remove( DwMime::kCte8bit );
+    allowedCtes.remove( DwMime::kCte7bit );
+  }
+
+  return allowedCtes;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBodyAndGuessCte( const QByteArray& aBuf,
+                                    QValueList<int> & allowedCte,
+                                    bool allow8Bit,
+                                    bool willBeSigned )
+{
+  CharFreq cf( aBuf ); // it's safe to pass null arrays
+
+  allowedCte = determineAllowedCtes( cf, allow8Bit, willBeSigned );
+
+#ifndef NDEBUG
+  DwString dwCte;
+  DwCteEnumToStr(allowedCte[0], dwCte);
+  kdDebug(5006) << "CharFreq returned " << cf.type() << "/"
+                << cf.printableRatio() << " and I chose "
+                << dwCte.c_str() << endl;
+#endif
+
+  setCte( allowedCte[0] ); // choose best fitting
+  setBodyEncodedBinary( aBuf );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBodyAndGuessCte( const QCString& aBuf,
+                                    QValueList<int> & allowedCte,
+                                    bool allow8Bit,
+                                    bool willBeSigned )
+{
+  CharFreq cf( aBuf.data(), aBuf.size()-1 ); // it's safe to pass null strings
+
+  allowedCte = determineAllowedCtes( cf, allow8Bit, willBeSigned );
+
+#ifndef NDEBUG
+  DwString dwCte;
+  DwCteEnumToStr(allowedCte[0], dwCte);
+  kdDebug(5006) << "CharFreq returned " << cf.type() << "/"
+                << cf.printableRatio() << " and I chose "
+                << dwCte.c_str() << endl;
+#endif
+
+  setCte( allowedCte[0] ); // choose best fitting
+  setBodyEncoded( aBuf );
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBodyEncoded(const QCString& aStr)
+{
+  DwString dwSrc(aStr.data(), aStr.size()-1 /* not the trailing NUL */);
+  DwString dwResult;
+
+  switch (cte())
+  {
+  case DwMime::kCteBase64:
+    DwEncodeBase64(dwSrc, dwResult);
+    break;
+  case DwMime::kCteQuotedPrintable:
+    DwEncodeQuotedPrintable(dwSrc, dwResult);
+    break;
+  default:
+    dwResult = dwSrc;
+    break;
+  }
+
+  mMsg->Body().FromString(dwResult);
+  mNeedsAssembly = true;
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBodyEncodedBinary(const QByteArray& aStr)
+{
+  DwString dwSrc(aStr.data(), aStr.size());
+  DwString dwResult;
+
+  switch (cte())
+  {
+  case DwMime::kCteBase64:
+    DwEncodeBase64(dwSrc, dwResult);
+    break;
+  case DwMime::kCteQuotedPrintable:
+    DwEncodeQuotedPrintable(dwSrc, dwResult);
+    break;
+  default:
+    dwResult = dwSrc;
+    break;
+  }
+
+  mMsg->Body().FromString(dwResult);
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setBody(const QCString& aStr)
+{
+  mMsg->Body().FromString(KMail::Util::dwString(aStr));
+  mNeedsAssembly = true;
+}
+void KMMessage::setBody(const DwString& aStr)
+{
+  mMsg->Body().FromString(aStr);
+  mNeedsAssembly = true;
+}
+void KMMessage::setBody(const char* aStr)
+{
+  mMsg->Body().FromString(aStr);
+  mNeedsAssembly = true;
+}
+
+void KMMessage::setMultiPartBody( const QCString & aStr ) {
+  setBody( aStr );
+  mMsg->Body().Parse();
+  mNeedsAssembly = true;
+}
+
+
+// Patched by Daniel Moisset <dmoisset@grulic.org.ar>
+// modified numbodyparts, bodypart to take nested body parts as
+// a linear sequence.
+// third revision, Sep 26 2000
+
+// this is support structure for traversing tree without recursion
+
+//-----------------------------------------------------------------------------
+int KMMessage::numBodyParts() const
+{
+  int count = 0;
+  DwBodyPart* part = getFirstDwBodyPart();
+  QPtrList< DwBodyPart > parts;
+
+  while (part)
+  {
+    //dive into multipart messages
+    while (    part
+            && part->hasHeaders()
+            && part->Headers().HasContentType()
+            && part->Body().FirstBodyPart()
+            && (DwMime::kTypeMultipart == part->Headers().ContentType().Type()) )
+    {
+      parts.append( part );
+      part = part->Body().FirstBodyPart();
+    }
+    // this is where currPart->msgPart contains a leaf message part
+    count++;
+    // go up in the tree until reaching a node with next
+    // (or the last top-level node)
+    while (part && !(part->Next()) && !(parts.isEmpty()))
+    {
+      part = parts.getLast();
+      parts.removeLast();
+    }
+
+    if (part && part->Body().Message() &&
+        part->Body().Message()->Body().FirstBodyPart())
+    {
+      part = part->Body().Message()->Body().FirstBodyPart();
+    } else if (part) {
+      part = part->Next();
+    }
+  }
+
+  return count;
+}
+
+
+//-----------------------------------------------------------------------------
+DwBodyPart * KMMessage::getFirstDwBodyPart() const
+{
+  return mMsg->Body().FirstBodyPart();
+}
+
+
+//-----------------------------------------------------------------------------
+int KMMessage::partNumber( DwBodyPart * aDwBodyPart ) const
+{
+  DwBodyPart *curpart;
+  QPtrList< DwBodyPart > parts;
+  int curIdx = 0;
+  int idx = 0;
+  // Get the DwBodyPart for this index
+
+  curpart = getFirstDwBodyPart();
+
+  while (curpart && !idx) {
+    //dive into multipart messages
+    while(    curpart
+           && curpart->hasHeaders()
+           && curpart->Headers().HasContentType()
+           && curpart->Body().FirstBodyPart()
+           && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) )
+    {
+      parts.append( curpart );
+      curpart = curpart->Body().FirstBodyPart();
+    }
+    // this is where currPart->msgPart contains a leaf message part
+    if (curpart == aDwBodyPart)
+      idx = curIdx;
+    curIdx++;
+    // go up in the tree until reaching a node with next
+    // (or the last top-level node)
+    while (curpart && !(curpart->Next()) && !(parts.isEmpty()))
+    {
+      curpart = parts.getLast();
+      parts.removeLast();
+    } ;
+    if (curpart)
+      curpart = curpart->Next();
+  }
+  return idx;
+}
+
+
+//-----------------------------------------------------------------------------
+DwBodyPart * KMMessage::dwBodyPart( int aIdx ) const
+{
+  DwBodyPart *part, *curpart;
+  QPtrList< DwBodyPart > parts;
+  int curIdx = 0;
+  // Get the DwBodyPart for this index
+
+  curpart = getFirstDwBodyPart();
+  part = 0;
+
+  while (curpart && !part) {
+    //dive into multipart messages
+    while(    curpart
+           && curpart->hasHeaders()
+           && curpart->Headers().HasContentType()
+           && curpart->Body().FirstBodyPart()
+           && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) )
+    {
+      parts.append( curpart );
+      curpart = curpart->Body().FirstBodyPart();
+    }
+    // this is where currPart->msgPart contains a leaf message part
+    if (curIdx==aIdx)
+        part = curpart;
+    curIdx++;
+    // go up in the tree until reaching a node with next
+    // (or the last top-level node)
+    while (curpart && !(curpart->Next()) && !(parts.isEmpty()))
+    {
+      curpart = parts.getLast();
+      parts.removeLast();
+    }
+    if (curpart)
+      curpart = curpart->Next();
+  }
+  return part;
+}
+
+
+//-----------------------------------------------------------------------------
+DwBodyPart * KMMessage::findDwBodyPart( int type, int subtype ) const
+{
+  DwBodyPart *part, *curpart;
+  QPtrList< DwBodyPart > parts;
+  // Get the DwBodyPart for this index
+
+  curpart = getFirstDwBodyPart();
+  part = 0;
+
+  while (curpart && !part) {
+    //dive into multipart messages
+    while(curpart
+	  && curpart->hasHeaders()
+	  && curpart->Headers().HasContentType()
+      && curpart->Body().FirstBodyPart()
+	  && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) {
+	parts.append( curpart );
+	curpart = curpart->Body().FirstBodyPart();
+    }
+    // this is where curPart->msgPart contains a leaf message part
+
+    // pending(khz): Find out WHY this look does not travel down *into* an
+    //               embedded "Message/RfF822" message containing a "Multipart/Mixed"
+    if ( curpart && curpart->hasHeaders() && curpart->Headers().HasContentType() ) {
+      kdDebug(5006) << curpart->Headers().ContentType().TypeStr().c_str()
+		<< "  " << curpart->Headers().ContentType().SubtypeStr().c_str() << endl;
+    }
+
+    if (curpart &&
+	curpart->hasHeaders() &&
+        curpart->Headers().HasContentType() &&
+	curpart->Headers().ContentType().Type() == type &&
+	curpart->Headers().ContentType().Subtype() == subtype) {
+	part = curpart;
+    } else {
+      // go up in the tree until reaching a node with next
+      // (or the last top-level node)
+      while (curpart && !(curpart->Next()) && !(parts.isEmpty())) {
+	curpart = parts.getLast();
+	parts.removeLast();
+      } ;
+      if (curpart)
+	curpart = curpart->Next();
+    }
+  }
+  return part;
+}
+
+//-----------------------------------------------------------------------------
+DwBodyPart * KMMessage::findDwBodyPart( const QCString& type, const QCString&  subtype ) const
+{
+  DwBodyPart *part, *curpart;
+  QPtrList< DwBodyPart > parts;
+  // Get the DwBodyPart for this index
+
+  curpart = getFirstDwBodyPart();
+  part = 0;
+
+  while (curpart && !part) {
+    //dive into multipart messages
+    while(curpart
+	  && curpart->hasHeaders()
+	  && curpart->Headers().HasContentType()
+      && curpart->Body().FirstBodyPart()
+	  && (DwMime::kTypeMultipart == curpart->Headers().ContentType().Type()) ) {
+	parts.append( curpart );
+	curpart = curpart->Body().FirstBodyPart();
+    }
+    // this is where curPart->msgPart contains a leaf message part
+
+    // pending(khz): Find out WHY this look does not travel down *into* an
+    //               embedded "Message/RfF822" message containing a "Multipart/Mixed"
+    if (curpart && curpart->hasHeaders() && curpart->Headers().HasContentType() ) {
+      kdDebug(5006) << curpart->Headers().ContentType().TypeStr().c_str()
+            << "  " << curpart->Headers().ContentType().SubtypeStr().c_str() << endl;
+    }
+
+    if (curpart &&
+	curpart->hasHeaders() &&
+        curpart->Headers().HasContentType() &&
+	curpart->Headers().ContentType().TypeStr().c_str() == type &&
+	curpart->Headers().ContentType().SubtypeStr().c_str() == subtype) {
+	part = curpart;
+    } else {
+      // go up in the tree until reaching a node with next
+      // (or the last top-level node)
+      while (curpart && !(curpart->Next()) && !(parts.isEmpty())) {
+	curpart = parts.getLast();
+	parts.removeLast();
+      } ;
+      if (curpart)
+	curpart = curpart->Next();
+    }
+  }
+  return part;
+}
+
+
+void applyHeadersToMessagePart( DwHeaders& headers, KMMessagePart* aPart )
+{
+  // TODO: Instead of manually implementing RFC2231 header encoding (i.e.
+  //       possibly multiple values given as paramname*0=..; parmaname*1=..;...
+  //       or par as paramname*0*=..; parmaname*1*=..;..., which should be
+  //       concatenated), use a generic method to decode the header, using RFC
+  //       2047 or 2231, or whatever future RFC might be appropriate!
+  //       Right now, some fields are decoded, while others are not. E.g.
+  //       Content-Disposition is not decoded here, rather only on demand in
+  //       KMMsgPart::fileName; Name however is decoded here and stored as a
+  //       decoded String in KMMsgPart...
+  // Content-type
+  QCString additionalCTypeParams;
+  if (headers.HasContentType())
+  {
+    DwMediaType& ct = headers.ContentType();
+    aPart->setOriginalContentTypeStr( ct.AsString().c_str() );
+    aPart->setTypeStr(ct.TypeStr().c_str());
+    aPart->setSubtypeStr(ct.SubtypeStr().c_str());
+    DwParameter *param = ct.FirstParameter();
+    while(param)
+    {
+      if (!qstricmp(param->Attribute().c_str(), "charset"))
+        aPart->setCharset(QCString(param->Value().c_str()).lower());
+      else if (!qstrnicmp(param->Attribute().c_str(), "name*", 5))
+        aPart->setName(KMMsgBase::decodeRFC2231String(KMMsgBase::extractRFC2231HeaderField( param->Value().c_str(), "name" )));
+      else {
+        additionalCTypeParams += ';';
+        additionalCTypeParams += param->AsString().c_str();
+      }
+      param=param->Next();
+    }
+  }
+  else
+  {
+    aPart->setTypeStr("text");      // Set to defaults
+    aPart->setSubtypeStr("plain");
+  }
+  aPart->setAdditionalCTypeParamStr( additionalCTypeParams );
+  // Modification by Markus
+  if (aPart->name().isEmpty())
+  {
+    if (headers.HasContentType() && !headers.ContentType().Name().empty()) {
+      aPart->setName(KMMsgBase::decodeRFC2047String(headers.
+            ContentType().Name().c_str()) );
+    } else if (headers.HasSubject() && !headers.Subject().AsString().empty()) {
+      aPart->setName( KMMsgBase::decodeRFC2047String(headers.
+            Subject().AsString().c_str()) );
+    }
+  }
+
+  // Content-transfer-encoding
+  if (headers.HasContentTransferEncoding())
+    aPart->setCteStr(headers.ContentTransferEncoding().AsString().c_str());
+  else
+    aPart->setCteStr("7bit");
+
+  // Content-description
+  if (headers.HasContentDescription())
+    aPart->setContentDescription(headers.ContentDescription().AsString().c_str());
+  else
+    aPart->setContentDescription("");
+
+  // Content-disposition
+  if (headers.HasContentDisposition())
+    aPart->setContentDisposition(headers.ContentDisposition().AsString().c_str());
+  else
+    aPart->setContentDisposition("");
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::bodyPart(DwBodyPart* aDwBodyPart, KMMessagePart* aPart,
+			 bool withBody)
+{
+  if ( !aPart )
+    return;
+
+  aPart->clear();
+
+  if( aDwBodyPart && aDwBodyPart->hasHeaders()  ) {
+    // This must not be an empty string, because we'll get a
+    // spurious empty Subject: line in some of the parts.
+    //aPart->setName(" ");
+    // partSpecifier
+    QString partId( aDwBodyPart->partId() );
+    aPart->setPartSpecifier( partId );
+
+    DwHeaders& headers = aDwBodyPart->Headers();
+    applyHeadersToMessagePart( headers, aPart );
+
+    // Body
+    if (withBody)
+      aPart->setBody( aDwBodyPart->Body().AsString() );
+    else
+      aPart->setBody( QCString("") );
+
+    // Content-id
+    if ( headers.HasContentId() ) {
+      const QCString contentId = headers.ContentId().AsString().c_str();
+      // ignore leading '<' and trailing '>'
+      aPart->setContentId( contentId.mid( 1, contentId.length() - 2 ) );
+    }
+  }
+  // If no valid body part was given,
+  // set all MultipartBodyPart attributes to empty values.
+  else
+  {
+    aPart->setTypeStr("");
+    aPart->setSubtypeStr("");
+    aPart->setCteStr("");
+    // This must not be an empty string, because we'll get a
+    // spurious empty Subject: line in some of the parts.
+    //aPart->setName(" ");
+    aPart->setContentDescription("");
+    aPart->setContentDisposition("");
+    aPart->setBody(QCString(""));
+    aPart->setContentId("");
+  }
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::bodyPart(int aIdx, KMMessagePart* aPart) const
+{
+  if ( !aPart )
+    return;
+
+  // If the DwBodyPart was found get the header fields and body
+  if ( DwBodyPart *part = dwBodyPart( aIdx ) ) {
+    KMMessage::bodyPart(part, aPart);
+    if( aPart->name().isEmpty() )
+      aPart->setName( i18n("Attachment: %1").arg( aIdx ) );
+  }
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::deleteBodyParts()
+{
+  mMsg->Body().DeleteBodyParts();
+}
+
+//-----------------------------------------------------------------------------
+DwBodyPart* KMMessage::createDWBodyPart(const KMMessagePart* aPart)
+{
+  DwBodyPart* part = DwBodyPart::NewBodyPart(emptyString, 0);
+
+  if ( !aPart )
+    return part;
+
+  QCString charset  = aPart->charset();
+  QCString type     = aPart->typeStr();
+  QCString subtype  = aPart->subtypeStr();
+  QCString cte      = aPart->cteStr();
+  QCString contDesc = aPart->contentDescriptionEncoded();
+  QCString contDisp = aPart->contentDisposition();
+  QCString encoding = autoDetectCharset(charset, sPrefCharsets, aPart->name());
+  if (encoding.isEmpty()) encoding = "utf-8";
+  QCString name     = KMMsgBase::encodeRFC2231String(aPart->name(), encoding);
+  bool RFC2231encoded = aPart->name() != QString(name);
+  QCString paramAttr  = aPart->parameterAttribute();
+
+  DwHeaders& headers = part->Headers();
+
+  DwMediaType& ct = headers.ContentType();
+  if (!type.isEmpty() && !subtype.isEmpty())
+  {
+    ct.SetTypeStr(type.data());
+    ct.SetSubtypeStr(subtype.data());
+    if (!charset.isEmpty()){
+      DwParameter *param;
+      param=new DwParameter;
+      param->SetAttribute("charset");
+      param->SetValue(charset.data());
+      ct.AddParameter(param);
+    }
+  }
+
+  QCString additionalParam = aPart->additionalCTypeParamStr();
+  if( !additionalParam.isEmpty() )
+  {
+    QCString parAV;
+    DwString parA, parV;
+    int iL, i1, i2, iM;
+    iL = additionalParam.length();
+    i1 = 0;
+    i2 = additionalParam.find(';', i1, false);
+    while ( i1 < iL )
+    {
+      if( -1 == i2 )
+	i2 = iL;
+      if( i1+1 < i2 ) {
+	parAV = additionalParam.mid( i1, (i2-i1) );
+	iM = parAV.find('=');
+	if( -1 < iM )
+        {
+	  parA = parAV.left( iM );
+	  parV = parAV.right( parAV.length() - iM - 1 );
+	  if( ('"' == parV.at(0)) && ('"' == parV.at(parV.length()-1)) )
+          {
+	    parV.erase( 0,  1);
+	    parV.erase( parV.length()-1 );
+	  }
+	}
+	else
+        {
+	  parA = parAV;
+	  parV = "";
+	}
+	DwParameter *param;
+	param = new DwParameter;
+	param->SetAttribute( parA );
+	param->SetValue(     parV );
+	ct.AddParameter( param );
+      }
+      i1 = i2+1;
+      i2 = additionalParam.find(';', i1, false);
+    }
+  }
+
+  if ( !name.isEmpty() ) {
+    if (RFC2231encoded)
+    {
+      DwParameter *nameParam;
+      nameParam = new DwParameter;
+      nameParam->SetAttribute("name*");
+      nameParam->SetValue(name.data(),true);
+      ct.AddParameter(nameParam);
+    } else {
+      ct.SetName(name.data());
+    }
+  }
+
+  if (!paramAttr.isEmpty())
+  {
+    QCString encoding = autoDetectCharset(charset, sPrefCharsets,
+					  aPart->parameterValue());
+    if (encoding.isEmpty()) encoding = "utf-8";
+    QCString paramValue;
+    paramValue = KMMsgBase::encodeRFC2231String(aPart->parameterValue(),
+						encoding);
+    DwParameter *param = new DwParameter;
+    if (aPart->parameterValue() != QString(paramValue))
+    {
+      param->SetAttribute((paramAttr + '*').data());
+      param->SetValue(paramValue.data(),true);
+    } else {
+      param->SetAttribute(paramAttr.data());
+      param->SetValue(paramValue.data());
+    }
+    ct.AddParameter(param);
+  }
+
+  if (!cte.isEmpty())
+    headers.Cte().FromString(cte);
+
+  if (!contDesc.isEmpty())
+    headers.ContentDescription().FromString(contDesc);
+
+  if (!contDisp.isEmpty())
+    headers.ContentDisposition().FromString(contDisp);
+
+  const DwString bodyStr = aPart->dwBody();
+  if (!bodyStr.empty())
+    part->Body().FromString(bodyStr);
+  else
+    part->Body().FromString("");
+
+  if (!aPart->partSpecifier().isNull())
+    part->SetPartId( aPart->partSpecifier().latin1() );
+
+  if (aPart->decodedSize() > 0)
+    part->SetBodySize( aPart->decodedSize() );
+
+  return part;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::addDwBodyPart(DwBodyPart * aDwPart)
+{
+  mMsg->Body().AddBodyPart( aDwPart );
+  mNeedsAssembly = true;
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::addBodyPart(const KMMessagePart* aPart)
+{
+  DwBodyPart* part = createDWBodyPart( aPart );
+  addDwBodyPart( part );
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::generateMessageId( const QString& addr )
+{
+  QDateTime datetime = QDateTime::currentDateTime();
+  QString msgIdStr;
+
+  msgIdStr = '<' + datetime.toString( "yyyyMMddhhmm.sszzz" );
+
+  QString msgIdSuffix;
+  KConfigGroup general( KMKernel::config(), "General" );
+
+  if( general.readBoolEntry( "useCustomMessageIdSuffix", false ) )
+    msgIdSuffix = general.readEntry( "myMessageIdSuffix" );
+
+  if( !msgIdSuffix.isEmpty() )
+    msgIdStr += '@' + msgIdSuffix;
+  else
+    msgIdStr += '.' + KPIM::encodeIDN( addr );
+
+  msgIdStr += '>';
+
+  return msgIdStr;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::html2source( const QCString & src )
+{
+  QCString result( 1 + 6*(src.size()-1) );  // maximal possible length
+
+  QCString::ConstIterator s = src.begin();
+  QCString::Iterator d = result.begin();
+  while ( *s ) {
+    switch ( *s ) {
+    case '<': {
+        *d++ = '&';
+        *d++ = 'l';
+        *d++ = 't';
+        *d++ = ';';
+        ++s;
+      }
+      break;
+    case '\r': {
+        ++s;
+      }
+      break;
+    case '\n': {
+        *d++ = '<';
+        *d++ = 'b';
+        *d++ = 'r';
+        *d++ = '>';
+        ++s;
+      }
+      break;
+    case '>': {
+        *d++ = '&';
+        *d++ = 'g';
+        *d++ = 't';
+        *d++ = ';';
+        ++s;
+      }
+      break;
+    case '&': {
+        *d++ = '&';
+        *d++ = 'a';
+        *d++ = 'm';
+        *d++ = 'p';
+        *d++ = ';';
+        ++s;
+      }
+      break;
+    case '"': {
+        *d++ = '&';
+        *d++ = 'q';
+        *d++ = 'u';
+        *d++ = 'o';
+        *d++ = 't';
+        *d++ = ';';
+        ++s;
+      }
+      break;
+    case '\'': {
+        *d++ = '&';
+	*d++ = 'a';
+	*d++ = 'p';
+	*d++ = 's';
+	*d++ = ';';
+	++s;
+      }
+      break;
+    default:
+        *d++ = *s++;
+    }
+  }
+  result.truncate( d - result.begin() ); // adds trailing NUL
+  return result;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::encodeMailtoUrl( const QString& str )
+{
+  QString result;
+  result = QString::fromLatin1( KMMsgBase::encodeRFC2047String( str,
+                                                                "utf-8" ) );
+  result = KURL::encode_string( result );
+  return result;
+}
+
+
+//-----------------------------------------------------------------------------
+QString KMMessage::decodeMailtoUrl( const QString& url )
+{
+  QString result;
+  result = KURL::decode_string( url );
+  result = KMMsgBase::decodeRFC2047String( result.latin1() );
+  return result;
+}
+
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::stripEmailAddr( const QCString& aStr )
+{
+  //kdDebug(5006) << "KMMessage::stripEmailAddr( " << aStr << " )" << endl;
+
+  if ( aStr.isEmpty() )
+    return QCString();
+
+  QCString result;
+
+  // The following is a primitive parser for a mailbox-list (cf. RFC 2822).
+  // The purpose is to extract a displayable string from the mailboxes.
+  // Comments in the addr-spec are not handled. No error checking is done.
+
+  QCString name;
+  QCString comment;
+  QCString angleAddress;
+  enum { TopLevel, InComment, InAngleAddress } context = TopLevel;
+  bool inQuotedString = false;
+  int commentLevel = 0;
+
+  for ( char* p = aStr.data(); *p; ++p ) {
+    switch ( context ) {
+    case TopLevel : {
+      switch ( *p ) {
+      case '"' : inQuotedString = !inQuotedString;
+                 break;
+      case '(' : if ( !inQuotedString ) {
+                   context = InComment;
+                   commentLevel = 1;
+                 }
+                 else
+                   name += *p;
+                 break;
+      case '<' : if ( !inQuotedString ) {
+                   context = InAngleAddress;
+                 }
+                 else
+                   name += *p;
+                 break;
+      case '\\' : // quoted character
+                 ++p; // skip the '\'
+                 if ( *p )
+                   name += *p;
+                 break;
+      case ',' : if ( !inQuotedString ) {
+                   // next email address
+                   if ( !result.isEmpty() )
+                     result += ", ";
+                   name = name.stripWhiteSpace();
+                   comment = comment.stripWhiteSpace();
+                   angleAddress = angleAddress.stripWhiteSpace();
+                   /*
+                   kdDebug(5006) << "Name    : \"" << name
+                                 << "\"" << endl;
+                   kdDebug(5006) << "Comment : \"" << comment
+                                 << "\"" << endl;
+                   kdDebug(5006) << "Address : \"" << angleAddress
+                                 << "\"" << endl;
+                   */
+                   if ( angleAddress.isEmpty() && !comment.isEmpty() ) {
+                     // handle Outlook-style addresses like
+                     // john.doe@invalid (John Doe)
+                     result += comment;
+                   }
+                   else if ( !name.isEmpty() ) {
+                     result += name;
+                   }
+                   else if ( !comment.isEmpty() ) {
+                     result += comment;
+                   }
+                   else if ( !angleAddress.isEmpty() ) {
+                     result += angleAddress;
+                   }
+                   name = QCString();
+                   comment = QCString();
+                   angleAddress = QCString();
+                 }
+                 else
+                   name += *p;
+                 break;
+      default :  name += *p;
+      }
+      break;
+    }
+    case InComment : {
+      switch ( *p ) {
+      case '(' : ++commentLevel;
+                 comment += *p;
+                 break;
+      case ')' : --commentLevel;
+                 if ( commentLevel == 0 ) {
+                   context = TopLevel;
+                   comment += ' '; // separate the text of several comments
+                 }
+                 else
+                   comment += *p;
+                 break;
+      case '\\' : // quoted character
+                 ++p; // skip the '\'
+                 if ( *p )
+                   comment += *p;
+                 break;
+      default :  comment += *p;
+      }
+      break;
+    }
+    case InAngleAddress : {
+      switch ( *p ) {
+      case '"' : inQuotedString = !inQuotedString;
+                 angleAddress += *p;
+                 break;
+      case '>' : if ( !inQuotedString ) {
+                   context = TopLevel;
+                 }
+                 else
+                   angleAddress += *p;
+                 break;
+      case '\\' : // quoted character
+                 ++p; // skip the '\'
+                 if ( *p )
+                   angleAddress += *p;
+                 break;
+      default :  angleAddress += *p;
+      }
+      break;
+    }
+    } // switch ( context )
+  }
+  if ( !result.isEmpty() )
+    result += ", ";
+  name = name.stripWhiteSpace();
+  comment = comment.stripWhiteSpace();
+  angleAddress = angleAddress.stripWhiteSpace();
+  /*
+  kdDebug(5006) << "Name    : \"" << name << "\"" << endl;
+  kdDebug(5006) << "Comment : \"" << comment << "\"" << endl;
+  kdDebug(5006) << "Address : \"" << angleAddress << "\"" << endl;
+  */
+  if ( angleAddress.isEmpty() && !comment.isEmpty() ) {
+    // handle Outlook-style addresses like
+    // john.doe@invalid (John Doe)
+    result += comment;
+  }
+  else if ( !name.isEmpty() ) {
+    result += name;
+  }
+  else if ( !comment.isEmpty() ) {
+    result += comment;
+  }
+  else if ( !angleAddress.isEmpty() ) {
+    result += angleAddress;
+  }
+
+  //kdDebug(5006) << "KMMessage::stripEmailAddr(...) returns \"" << result
+  //              << "\"" << endl;
+  return result;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::stripEmailAddr( const QString& aStr )
+{
+  //kdDebug(5006) << "KMMessage::stripEmailAddr( " << aStr << " )" << endl;
+
+  if ( aStr.isEmpty() )
+    return QString::null;
+
+  QString result;
+
+  // The following is a primitive parser for a mailbox-list (cf. RFC 2822).
+  // The purpose is to extract a displayable string from the mailboxes.
+  // Comments in the addr-spec are not handled. No error checking is done.
+
+  QString name;
+  QString comment;
+  QString angleAddress;
+  enum { TopLevel, InComment, InAngleAddress } context = TopLevel;
+  bool inQuotedString = false;
+  int commentLevel = 0;
+
+  QChar ch;
+  unsigned int strLength(aStr.length());
+  for ( uint index = 0; index < strLength; ++index ) {
+    ch = aStr[index];
+    switch ( context ) {
+    case TopLevel : {
+      switch ( ch.latin1() ) {
+      case '"' : inQuotedString = !inQuotedString;
+                 break;
+      case '(' : if ( !inQuotedString ) {
+                   context = InComment;
+                   commentLevel = 1;
+                 }
+                 else
+                   name += ch;
+                 break;
+      case '<' : if ( !inQuotedString ) {
+                   context = InAngleAddress;
+                 }
+                 else
+                   name += ch;
+                 break;
+      case '\\' : // quoted character
+                 ++index; // skip the '\'
+                 if ( index < aStr.length() )
+                   name += aStr[index];
+                 break;
+      case ',' : if ( !inQuotedString ) {
+                   // next email address
+                   if ( !result.isEmpty() )
+                     result += ", ";
+                   name = name.stripWhiteSpace();
+                   comment = comment.stripWhiteSpace();
+                   angleAddress = angleAddress.stripWhiteSpace();
+                   /*
+                   kdDebug(5006) << "Name    : \"" << name
+                                 << "\"" << endl;
+                   kdDebug(5006) << "Comment : \"" << comment
+                                 << "\"" << endl;
+                   kdDebug(5006) << "Address : \"" << angleAddress
+                                 << "\"" << endl;
+                   */
+                   if ( angleAddress.isEmpty() && !comment.isEmpty() ) {
+                     // handle Outlook-style addresses like
+                     // john.doe@invalid (John Doe)
+                     result += comment;
+                   }
+                   else if ( !name.isEmpty() ) {
+                     result += name;
+                   }
+                   else if ( !comment.isEmpty() ) {
+                     result += comment;
+                   }
+                   else if ( !angleAddress.isEmpty() ) {
+                     result += angleAddress;
+                   }
+                   name = QString::null;
+                   comment = QString::null;
+                   angleAddress = QString::null;
+                 }
+                 else
+                   name += ch;
+                 break;
+      default :  name += ch;
+      }
+      break;
+    }
+    case InComment : {
+      switch ( ch.latin1() ) {
+      case '(' : ++commentLevel;
+                 comment += ch;
+                 break;
+      case ')' : --commentLevel;
+                 if ( commentLevel == 0 ) {
+                   context = TopLevel;
+                   comment += ' '; // separate the text of several comments
+                 }
+                 else
+                   comment += ch;
+                 break;
+      case '\\' : // quoted character
+                 ++index; // skip the '\'
+                 if ( index < aStr.length() )
+                   comment += aStr[index];
+                 break;
+      default :  comment += ch;
+      }
+      break;
+    }
+    case InAngleAddress : {
+      switch ( ch.latin1() ) {
+      case '"' : inQuotedString = !inQuotedString;
+                 angleAddress += ch;
+                 break;
+      case '>' : if ( !inQuotedString ) {
+                   context = TopLevel;
+                 }
+                 else
+                   angleAddress += ch;
+                 break;
+      case '\\' : // quoted character
+                 ++index; // skip the '\'
+                 if ( index < aStr.length() )
+                   angleAddress += aStr[index];
+                 break;
+      default :  angleAddress += ch;
+      }
+      break;
+    }
+    } // switch ( context )
+  }
+  if ( !result.isEmpty() )
+    result += ", ";
+  name = name.stripWhiteSpace();
+  comment = comment.stripWhiteSpace();
+  angleAddress = angleAddress.stripWhiteSpace();
+  /*
+  kdDebug(5006) << "Name    : \"" << name << "\"" << endl;
+  kdDebug(5006) << "Comment : \"" << comment << "\"" << endl;
+  kdDebug(5006) << "Address : \"" << angleAddress << "\"" << endl;
+  */
+  if ( angleAddress.isEmpty() && !comment.isEmpty() ) {
+    // handle Outlook-style addresses like
+    // john.doe@invalid (John Doe)
+    result += comment;
+  }
+  else if ( !name.isEmpty() ) {
+    result += name;
+  }
+  else if ( !comment.isEmpty() ) {
+    result += comment;
+  }
+  else if ( !angleAddress.isEmpty() ) {
+    result += angleAddress;
+  }
+
+  //kdDebug(5006) << "KMMessage::stripEmailAddr(...) returns \"" << result
+  //              << "\"" << endl;
+  return result;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::quoteHtmlChars( const QString& str, bool removeLineBreaks )
+{
+  QString result;
+
+  unsigned int strLength(str.length());
+  result.reserve( 6*strLength ); // maximal possible length
+  for( unsigned int i = 0; i < strLength; ++i )
+    switch ( str[i].latin1() ) {
+    case '<':
+      result += "&lt;";
+      break;
+    case '>':
+      result += "&gt;";
+      break;
+    case '&':
+      result += "&amp;";
+      break;
+    case '"':
+      result += "&quot;";
+      break;
+    case '\n':
+      if ( !removeLineBreaks )
+	result += "<br>";
+      break;
+    case '\r':
+      // ignore CR
+      break;
+    default:
+      result += str[i];
+    }
+
+  result.squeeze();
+  return result;
+}
+
+//-----------------------------------------------------------------------------
+QString KMMessage::emailAddrAsAnchor(const QString& aEmail, bool stripped, const QString& cssStyle, bool aLink)
+{
+  if( aEmail.isEmpty() )
+    return aEmail;
+
+  QStringList addressList = KPIM::splitEmailAddrList( aEmail );
+
+  QString result;
+
+  for( QStringList::ConstIterator it = addressList.begin();
+       ( it != addressList.end() );
+       ++it ) {
+    if( !(*it).isEmpty() ) {
+      QString address = *it;
+      if(aLink) {
+	result += "<a href=\"mailto:"
+              + KMMessage::encodeMailtoUrl( address )
+	  + "\" "+cssStyle+">";
+      }
+      if( stripped )
+        address = KMMessage::stripEmailAddr( address );
+      result += KMMessage::quoteHtmlChars( address, true );
+      if(aLink)
+	result += "</a>, ";
+    }
+  }
+  // cut of the trailing ", "
+  if(aLink)
+    result.truncate( result.length() - 2 );
+
+  //kdDebug(5006) << "KMMessage::emailAddrAsAnchor('" << aEmail
+  //              << "') returns:\n-->" << result << "<--" << endl;
+  return result;
+}
+
+
+//-----------------------------------------------------------------------------
+//static
+QStringList KMMessage::stripAddressFromAddressList( const QString& address,
+                                                    const QStringList& list )
+{
+  QStringList addresses( list );
+  QString addrSpec( KPIM::getEmailAddress( address ) );
+  for ( QStringList::Iterator it = addresses.begin();
+       it != addresses.end(); ) {
+    if ( kasciistricmp( addrSpec.utf8().data(),
+                        KPIM::getEmailAddress( *it ).utf8().data() ) == 0 ) {
+      kdDebug(5006) << "Removing " << *it << " from the address list"
+                    << endl;
+      it = addresses.remove( it );
+    }
+    else
+      ++it;
+  }
+  return addresses;
+}
+
+
+//-----------------------------------------------------------------------------
+//static
+QStringList KMMessage::stripMyAddressesFromAddressList( const QStringList& list )
+{
+  QStringList addresses = list;
+  for( QStringList::Iterator it = addresses.begin();
+       it != addresses.end(); ) {
+    kdDebug(5006) << "Check whether " << *it << " is one of my addresses"
+                  << endl;
+    if( kmkernel->identityManager()->thatIsMe( KPIM::getEmailAddress( *it ) ) ) {
+      kdDebug(5006) << "Removing " << *it << " from the address list"
+                    << endl;
+      it = addresses.remove( it );
+    }
+    else
+      ++it;
+  }
+  return addresses;
+}
+
+
+//-----------------------------------------------------------------------------
+//static
+bool KMMessage::addressIsInAddressList( const QString& address,
+                                        const QStringList& addresses )
+{
+  QString addrSpec = KPIM::getEmailAddress( address );
+  for( QStringList::ConstIterator it = addresses.begin();
+       it != addresses.end(); ++it ) {
+    if ( kasciistricmp( addrSpec.utf8().data(),
+                        KPIM::getEmailAddress( *it ).utf8().data() ) == 0 )
+      return true;
+  }
+  return false;
+}
+
+
+//-----------------------------------------------------------------------------
+//static
+QString KMMessage::expandAliases( const QString& recipients )
+{
+  if ( recipients.isEmpty() )
+    return QString();
+
+  QStringList recipientList = KPIM::splitEmailAddrList( recipients );
+
+  QString expandedRecipients;
+  for ( QStringList::Iterator it = recipientList.begin();
+        it != recipientList.end(); ++it ) {
+    if ( !expandedRecipients.isEmpty() )
+      expandedRecipients += ", ";
+    QString receiver = (*it).stripWhiteSpace();
+
+    // try to expand distribution list
+    QString expandedList = KAddrBookExternal::expandDistributionList( receiver );
+    if ( !expandedList.isEmpty() ) {
+      expandedRecipients += expandedList;
+      continue;
+    }
+
+    // try to expand nick name
+    QString expandedNickName = KabcBridge::expandNickName( receiver );
+    if ( !expandedNickName.isEmpty() ) {
+      expandedRecipients += expandedNickName;
+      continue;
+    }
+
+    // check whether the address is missing the domain part
+    // FIXME: looking for '@' might be wrong
+    if ( receiver.find('@') == -1 ) {
+      KConfigGroup general( KMKernel::config(), "General" );
+      QString defaultdomain = general.readEntry( "Default domain" );
+      if( !defaultdomain.isEmpty() ) {
+        expandedRecipients += receiver + "@" + defaultdomain;
+      }
+      else {
+        expandedRecipients += guessEmailAddressFromLoginName( receiver );
+      }
+    }
+    else
+      expandedRecipients += receiver;
+  }
+
+  return expandedRecipients;
+}
+
+
+//-----------------------------------------------------------------------------
+//static
+QString KMMessage::guessEmailAddressFromLoginName( const QString& loginName )
+{
+  if ( loginName.isEmpty() )
+    return QString();
+
+  char hostnameC[256];
+  // null terminate this C string
+  hostnameC[255] = '\0';
+  // set the string to 0 length if gethostname fails
+  if ( gethostname( hostnameC, 255 ) )
+    hostnameC[0] = '\0';
+  QString address = loginName;
+  address += '@';
+  address += QString::fromLocal8Bit( hostnameC );
+
+  // try to determine the real name
+  const KUser user( loginName );
+  if ( user.isValid() ) {
+    QString fullName = user.fullName();
+    if ( fullName.find( QRegExp( "[^ 0-9A-Za-z\\x0080-\\xFFFF]" ) ) != -1 )
+      address = '"' + fullName.replace( '\\', "\\" ).replace( '"', "\\" )
+	      + "\" <" + address + '>';
+    else
+      address = fullName + " <" + address + '>';
+  }
+
+  return address;
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::readConfig()
+{
+  KMMsgBase::readConfig();
+
+  KConfig *config=KMKernel::config();
+  KConfigGroupSaver saver(config, "General");
+
+  config->setGroup("General");
+
+  int languageNr = config->readNumEntry("reply-current-language",0);
+
+  { // area for config group "KMMessage #n"
+    KConfigGroupSaver saver(config, QString("KMMessage #%1").arg(languageNr));
+    sReplyLanguage = config->readEntry("language",KGlobal::locale()->language());
+    sReplyStr = config->readEntry("phrase-reply",
+      i18n("On %D, you wrote:"));
+    sReplyAllStr = config->readEntry("phrase-reply-all",
+      i18n("On %D, %F wrote:"));
+    sForwardStr = config->readEntry("phrase-forward",
+      i18n("Forwarded Message"));
+    sIndentPrefixStr = config->readEntry("indent-prefix",">%_");
+  }
+
+  { // area for config group "Composer"
+    KConfigGroupSaver saver(config, "Composer");
+    sSmartQuote = GlobalSettings::self()->smartQuote();
+    sWordWrap = GlobalSettings::self()->wordWrap();
+    sWrapCol = GlobalSettings::self()->lineWrapWidth();
+    if ((sWrapCol == 0) || (sWrapCol > 78))
+      sWrapCol = 78;
+    if (sWrapCol < 30)
+      sWrapCol = 30;
+
+    sPrefCharsets = config->readListEntry("pref-charsets");
+  }
+
+  { // area for config group "Reader"
+    KConfigGroupSaver saver(config, "Reader");
+    sHeaderStrategy = HeaderStrategy::create( config->readEntry( "header-set-displayed", "rich" ) );
+  }
+}
+
+QCString KMMessage::defaultCharset()
+{
+  QCString retval;
+
+  if (!sPrefCharsets.isEmpty())
+    retval = sPrefCharsets[0].latin1();
+
+  if (retval.isEmpty()  || (retval == "locale")) {
+    retval = QCString(kmkernel->networkCodec()->mimeName());
+    KPIM::kAsciiToLower( retval.data() );
+  }
+
+  if (retval == "jisx0208.1983-0") retval = "iso-2022-jp";
+  else if (retval == "ksc5601.1987-0") retval = "euc-kr";
+  return retval;
+}
+
+const QStringList &KMMessage::preferredCharsets()
+{
+  return sPrefCharsets;
+}
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::charset() const
+{
+  if ( mMsg->Headers().HasContentType() ) {
+    DwMediaType &mType=mMsg->Headers().ContentType();
+    mType.Parse();
+    DwParameter *param=mType.FirstParameter();
+    while(param){
+      if (!kasciistricmp(param->Attribute().c_str(), "charset"))
+        return param->Value().c_str();
+      else param=param->Next();
+    }
+  }
+  return ""; // us-ascii, but we don't have to specify it
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::setCharset(const QCString& bStr)
+{
+  kdWarning( type() != DwMime::kTypeText )
+    << "KMMessage::setCharset(): trying to set a charset for a non-textual mimetype." << endl
+    << "Fix this caller:" << endl
+    << "====================================================================" << endl
+    << kdBacktrace( 5 ) << endl
+    << "====================================================================" << endl;
+  QCString aStr = bStr;
+  KPIM::kAsciiToLower( aStr.data() );
+  DwMediaType &mType = dwContentType();
+  mType.Parse();
+  DwParameter *param=mType.FirstParameter();
+  while(param)
+    // FIXME use the mimelib functions here for comparison.
+    if (!kasciistricmp(param->Attribute().c_str(), "charset")) break;
+    else param=param->Next();
+  if (!param){
+    param=new DwParameter;
+    param->SetAttribute("charset");
+    mType.AddParameter(param);
+  }
+  else
+    mType.SetModified();
+  param->SetValue(DwString(aStr));
+  mType.Assemble();
+}
+
+
+//-----------------------------------------------------------------------------
+void KMMessage::setStatus(const KMMsgStatus aStatus, int idx)
+{
+  if (mStatus == aStatus)
+    return;
+  KMMsgBase::setStatus(aStatus, idx);
+}
+
+void KMMessage::setEncryptionState(const KMMsgEncryptionState s, int idx)
+{
+    if( mEncryptionState == s )
+        return;
+    mEncryptionState = s;
+    mDirty = true;
+    KMMsgBase::setEncryptionState(s, idx);
+}
+
+void KMMessage::setSignatureState(KMMsgSignatureState s, int idx)
+{
+    if( mSignatureState == s )
+        return;
+    mSignatureState = s;
+    mDirty = true;
+    KMMsgBase::setSignatureState(s, idx);
+}
+
+void KMMessage::setMDNSentState( KMMsgMDNSentState status, int idx ) {
+  if ( mMDNSentState == status )
+    return;
+  if ( status == 0 )
+    status = KMMsgMDNStateUnknown;
+  mMDNSentState = status;
+  mDirty = true;
+  KMMsgBase::setMDNSentState( status, idx );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::link( const KMMessage *aMsg, KMMsgStatus aStatus )
+{
+  Q_ASSERT( aStatus == KMMsgStatusReplied
+      || aStatus == KMMsgStatusForwarded
+      || aStatus == KMMsgStatusDeleted );
+
+  QString message = headerField( "X-KMail-Link-Message" );
+  if ( !message.isEmpty() )
+    message += ',';
+  QString type = headerField( "X-KMail-Link-Type" );
+  if ( !type.isEmpty() )
+    type += ',';
+
+  message += QString::number( aMsg->getMsgSerNum() );
+  if ( aStatus == KMMsgStatusReplied )
+    type += "reply";
+  else if ( aStatus == KMMsgStatusForwarded )
+    type += "forward";
+  else if ( aStatus == KMMsgStatusDeleted )
+    type += "deleted";
+
+  setHeaderField( "X-KMail-Link-Message", message );
+  setHeaderField( "X-KMail-Link-Type", type );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::getLink(int n, ulong *retMsgSerNum, KMMsgStatus *retStatus) const
+{
+  *retMsgSerNum = 0;
+  *retStatus = KMMsgStatusUnknown;
+
+  QString message = headerField("X-KMail-Link-Message");
+  QString type = headerField("X-KMail-Link-Type");
+  message = message.section(',', n, n);
+  type = type.section(',', n, n);
+
+  if ( !message.isEmpty() && !type.isEmpty() ) {
+    *retMsgSerNum = message.toULong();
+    if ( type == "reply" )
+      *retStatus = KMMsgStatusReplied;
+    else if ( type == "forward" )
+      *retStatus = KMMsgStatusForwarded;
+    else if ( type == "deleted" )
+      *retStatus = KMMsgStatusDeleted;
+  }
+}
+
+//-----------------------------------------------------------------------------
+DwBodyPart* KMMessage::findDwBodyPart( DwBodyPart* part, const QString & partSpecifier )
+{
+  if ( !part ) return 0;
+  DwBodyPart* current;
+
+  if ( part->partId() == partSpecifier )
+    return part;
+
+  // multipart
+  if ( part->hasHeaders() &&
+       part->Headers().HasContentType() &&
+       part->Body().FirstBodyPart() &&
+       (DwMime::kTypeMultipart == part->Headers().ContentType().Type() ) &&
+       (current = findDwBodyPart( part->Body().FirstBodyPart(), partSpecifier )) )
+  {
+    return current;
+  }
+
+  // encapsulated message
+  if ( part->Body().Message() &&
+       part->Body().Message()->Body().FirstBodyPart() &&
+       (current = findDwBodyPart( part->Body().Message()->Body().FirstBodyPart(),
+                                  partSpecifier )) )
+  {
+    return current;
+  }
+
+  // next part
+  return findDwBodyPart( part->Next(), partSpecifier );
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::updateBodyPart(const QString partSpecifier, const QByteArray & data)
+{
+  if ( !data.data() || !data.size() )
+    return;
+
+  DwString content( data.data(), data.size() );
+  if ( numBodyParts() > 0 &&
+       partSpecifier != "0" &&
+       partSpecifier != "TEXT" )
+  {
+    QString specifier = partSpecifier;
+    if ( partSpecifier.endsWith(".HEADER") ||
+         partSpecifier.endsWith(".MIME") ) {
+      // get the parent bodypart
+      specifier = partSpecifier.section( '.', 0, -2 );
+    }
+
+    // search for the bodypart
+    mLastUpdated = findDwBodyPart( getFirstDwBodyPart(), specifier );
+    kdDebug(5006) << "KMMessage::updateBodyPart " << specifier << endl;
+    if (!mLastUpdated)
+    {
+      kdWarning(5006) << "KMMessage::updateBodyPart - can not find part "
+        << specifier << endl;
+      return;
+    }
+    if ( partSpecifier.endsWith(".MIME") )
+    {
+      // update headers
+      // get rid of EOL
+      content.resize( QMAX( content.length(), 2 ) - 2 );
+      // we have to delete the fields first as they might have been created by
+      // an earlier call to DwHeaders::FieldBody
+      mLastUpdated->Headers().DeleteAllFields();
+      mLastUpdated->Headers().FromString( content );
+      mLastUpdated->Headers().Parse();
+    } else if ( partSpecifier.endsWith(".HEADER") )
+    {
+      // update header of embedded message
+      mLastUpdated->Body().Message()->Headers().FromString( content );
+      mLastUpdated->Body().Message()->Headers().Parse();
+    } else {
+      // update body
+      mLastUpdated->Body().FromString( content );
+      QString parentSpec = partSpecifier.section( '.', 0, -2 );
+      if ( !parentSpec.isEmpty() )
+      {
+        DwBodyPart* parent = findDwBodyPart( getFirstDwBodyPart(), parentSpec );
+        if ( parent && parent->hasHeaders() && parent->Headers().HasContentType() )
+        {
+          const DwMediaType& contentType = parent->Headers().ContentType();
+          if ( contentType.Type() == DwMime::kTypeMessage &&
+               contentType.Subtype() == DwMime::kSubtypeRfc822 )
+          {
+            // an embedded message that is not multipart
+            // update this directly
+            parent->Body().Message()->Body().FromString( content );
+          }
+        }
+      }
+    }
+
+  } else
+  {
+    // update text-only messages
+    if ( partSpecifier == "TEXT" )
+      deleteBodyParts(); // delete empty parts first
+    mMsg->Body().FromString( content );
+    mMsg->Body().Parse();
+  }
+  mNeedsAssembly = true;
+  if (! partSpecifier.endsWith(".HEADER") )
+  {
+    // notify observers
+    notify();
+  }
+}
+
+//-----------------------------------------------------------------------------
+void KMMessage::updateAttachmentState( DwBodyPart* part )
+{
+  if ( !part )
+    part = getFirstDwBodyPart();
+
+  if ( !part )
+  {
+    // kdDebug(5006) << "updateAttachmentState - no part!" << endl;
+    setStatus( KMMsgStatusHasNoAttach );
+    return;
+  }
+
+  bool filenameEmpty = true;
+  if ( part->hasHeaders() ) {
+    if ( part->Headers().HasContentDisposition() ) {
+      DwDispositionType cd = part->Headers().ContentDisposition();
+      filenameEmpty = cd.Filename().empty();
+      if ( filenameEmpty ) {
+        // let's try if it is rfc 2231 encoded which mimelib can't handle
+        filenameEmpty = KMMsgBase::decodeRFC2231String( KMMsgBase::extractRFC2231HeaderField( cd.AsString().c_str(), "filename" ) ).isEmpty();
+      }
+    }
+  }
+
+  if ( part->hasHeaders() &&
+       ( ( part->Headers().HasContentDisposition() &&
+           !part->Headers().ContentDisposition().Filename().empty() ) ||
+         ( part->Headers().HasContentType() &&
+           !filenameEmpty ) ) )
+  {
+    // now blacklist certain ContentTypes
+    if ( !part->Headers().HasContentType() ||
+         ( part->Headers().HasContentType() &&
+           part->Headers().ContentType().Subtype() != DwMime::kSubtypePgpSignature &&
+           part->Headers().ContentType().Subtype() != DwMime::kSubtypePkcs7Signature ) )
+    {
+      setStatus( KMMsgStatusHasAttach );
+    }
+    return;
+  }
+
+  // multipart
+  if ( part->hasHeaders() &&
+       part->Headers().HasContentType() &&
+       part->Body().FirstBodyPart() &&
+       (DwMime::kTypeMultipart == part->Headers().ContentType().Type() ) )
+  {
+    updateAttachmentState( part->Body().FirstBodyPart() );
+  }
+
+  // encapsulated message
+  if ( part->Body().Message() &&
+       part->Body().Message()->Body().FirstBodyPart() )
+  {
+    updateAttachmentState( part->Body().Message()->Body().FirstBodyPart() );
+  }
+
+  // next part
+  if ( part->Next() )
+    updateAttachmentState( part->Next() );
+  else if ( attachmentState() == KMMsgAttachmentUnknown )
+    setStatus( KMMsgStatusHasNoAttach );
+}
+
+void KMMessage::setBodyFromUnicode( const QString & str ) {
+  QCString encoding = KMMsgBase::autoDetectCharset( charset(), KMMessage::preferredCharsets(), str );
+  if ( encoding.isEmpty() )
+    encoding = "utf-8";
+  const QTextCodec * codec = KMMsgBase::codecForName( encoding );
+  assert( codec );
+  QValueList<int> dummy;
+  setCharset( encoding );
+  setBodyAndGuessCte( codec->fromUnicode( str ), dummy, false /* no 8bit */ );
+}
+
+const QTextCodec * KMMessage::codec() const {
+  const QTextCodec * c = mOverrideCodec;
+  if ( !c )
+    // no override-codec set for this message, try the CT charset parameter:
+    c = KMMsgBase::codecForName( charset() );
+  if ( !c ) {
+    // Ok, no override and nothing in the message, let's use the fallback
+    // the user configured
+    c = KMMsgBase::codecForName( GlobalSettings::self()->fallbackCharacterEncoding().latin1() );
+  }
+  if ( !c )
+    // no charset means us-ascii (RFC 2045), so using local encoding should
+    // be okay
+    c = kmkernel->networkCodec();
+  assert( c );
+  return c;
+}
+
+QString KMMessage::bodyToUnicode(const QTextCodec* codec) const {
+  if ( !codec )
+    // No codec was given, so try the charset in the mail
+    codec = this->codec();
+  assert( codec );
+
+  return codec->toUnicode( bodyDecoded() );
+}
+
+//-----------------------------------------------------------------------------
+QCString KMMessage::mboxMessageSeparator()
+{
+  QCString str( KPIM::getFirstEmailAddress( rawHeaderField("From") ) );
+  if ( str.isEmpty() )
+    str = "unknown@unknown.invalid";
+  QCString dateStr( dateShortStr() );
+  if ( dateStr.isEmpty() ) {
+    time_t t = ::time( 0 );
+    dateStr = ctime( &t );
+    const int len = dateStr.length();
+    if ( dateStr[len-1] == '\n' )
+      dateStr.truncate( len - 1 );
+  }
+  return "From " + str + " " + dateStr + "\n";
+}
+
+void KMMessage::deleteWhenUnused()
+{
+  sPendingDeletes << this;
+}