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, 916 insertions, 0 deletions

diff --git a/kmail/kmmessage.h b/kmail/kmmessage.h
new file mode 100644
index 000000000..a19c9d510
--- /dev/null
+++ b/kmail/kmmessage.h
@@ -0,0 +1,916 @@
+// -*- mode: C++; c-file-style: "gnu" -*-
+/* kmmessage.h: Mime Message Class
+ *
+ */
+#ifndef kmmessage_h
+#define kmmessage_h
+
+/** @file This file defines Mime Message classes. */
+
+// for large file support
+#include <config.h>
+#include <sys/types.h>
+
+#include <mimelib/string.h>
+#include "kmmsgbase.h"
+#include "isubject.h"
+
+#include <kmime_mdn.h>
+
+#include<libemailfunctions/email.h>
+
+template <typename T>
+class QValueList;
+
+class QStringList;
+class QString;
+class QTextCodec;
+class QStrList;
+
+class KMFolder;
+class KMFolderIndex;
+class DwMessage;
+class KMMessagePart;
+class KMMsgInfo;
+class KMHeaders;
+class KMForwardDigestCommand;
+
+namespace KMime {
+  class CharFreq;
+  namespace Types {
+    class AddrSpec;
+    class Address;
+    typedef QValueList<Address> AddressList;
+    typedef QValueList<AddrSpec> AddrSpecList;
+  }
+}
+
+namespace KMail {
+  class HeaderStrategy;
+}
+
+class DwBodyPart;
+class DwMediaType;
+class DwHeaders;
+
+class partNode;
+
+namespace KMail {
+  enum ReplyStrategy { ReplySmart = 0,
+                       ReplyAuthor,
+                       ReplyList,
+                       ReplyAll,
+                       ReplyNone };
+}
+
+/** This is a Mime Message. */
+class KMMessage: public KMMsgBase, public KMail::ISubject
+{
+  friend class ::KMForwardDigestCommand; // needed for MIME Digest forward
+
+public:
+  // promote some of KMMsgBase's methods to public:
+  using KMMsgBase::parent;
+  using KMMsgBase::setParent;
+  using KMMsgBase::enableUndo; // KMFolder
+  using KMMsgBase::setEnableUndo; // dto.
+  using KMMsgBase::isRead; // dto.
+  using KMMsgBase::isUnread; // dto.
+  using KMMsgBase::isNew; // dto.
+  using KMMsgBase::isOld;
+  using KMMsgBase::isWatched;
+  using KMMsgBase::isIgnored;
+  using KMMsgBase::setEncryptionStateChar; // KMAcct*
+  using KMMsgBase::setSignatureStateChar; // dto.
+
+  /** Straight forward initialization. */
+  KMMessage(KMFolder* parent=0);
+
+  /** Constructor from a DwMessage. KMMessage takes possession of the
+      DwMessage, so don't dare to delete it.
+  */
+  KMMessage(DwMessage*);
+
+  /** Copy constructor. Does *not* automatically load the message. */
+  KMMessage(KMMsgInfo& msgInfo);
+
+  /** Copy constructor. */
+  KMMessage( const KMMessage& other );
+
+#if 0 // currently unused
+  /** Assignment operator. */
+  const KMMessage& operator=( const KMMessage& other ) {
+    if( &other == this )
+      return *this;
+    assign( other );
+    return *this;
+  }
+#endif
+
+  /** Destructor. */
+  virtual ~KMMessage();
+
+  /** Get KMMsgBase for this object */
+  KMMsgBase & toMsgBase() { return *this; }
+  const KMMsgBase & toMsgBase() const { return *this; }
+
+  /** Returns TRUE if object is a real message (not KMMsgInfo or KMMsgBase) */
+  bool isMessage() const;
+
+  /** @return whether the priority: or x-priority headers indicate
+       that this message should be considered urgent
+   **/
+  bool isUrgent() const;
+
+  /** Specifies an unencrypted copy of this message to be stored
+      in a separate member variable to allow saving messages in
+      unencrypted form that were sent in encrypted form.
+      NOTE: Ownership of @p unencrypted transfers to this KMMessage,
+            and it will be deleted in the d'tor.
+  */
+  void setUnencryptedMsg( KMMessage* unencrypted );
+
+  /** Returns TRUE if the message contains an unencrypted copy of itself. */
+  bool hasUnencryptedMsg() const { return 0 != mUnencryptedMsg; }
+
+  /** Returns an unencrypted copy of this message or 0 if none exists. */
+  KMMessage* unencryptedMsg() const { return mUnencryptedMsg; }
+
+  /** Returns an unencrypted copy of this message or 0 if none exists.
+      \note This function removes the internal unencrypted message pointer
+      from the message: the process calling takeUnencryptedMsg() must
+      delete the returned pointer when no longer needed.
+  */
+  KMMessage* takeUnencryptedMsg()
+  {
+    KMMessage* ret = mUnencryptedMsg;
+    mUnencryptedMsg = 0;
+    return ret;
+  }
+
+  /** Mark the message as deleted */
+  void del() { setStatus(KMMsgStatusDeleted); }
+
+  /** Undelete the message. Same as touch */
+  void undel() { setStatus(KMMsgStatusOld); }
+
+  /** Touch the message - mark it as read */
+  void touch() { setStatus(KMMsgStatusOld); }
+
+  /** Create a new message that is a reply to this message, filling all
+      required header fields with the proper values. The returned message
+      is not stored in any folder. Marks this message as replied. */
+  KMMessage* createReply( KMail::ReplyStrategy replyStrategy = KMail::ReplySmart,
+                          QString selection=QString::null, bool noQuote=false,
+                          bool allowDecryption=true, bool selectionIsBody=false,
+                          const QString &tmpl = QString::null );
+
+  /** Create a new message that is a redirect to this message, filling all
+    required header fields with the proper values. The returned message
+    is not stored in any folder. Marks this message as replied.
+    Redirects differ from forwards so they are forwarded to some other
+    user, mail is not changed and the reply-to field is set to
+    the email address of the original sender
+   */
+  KMMessage* createRedirect( const QString &toStr );
+
+  /** Create the forwarded body for the message. */
+  QCString createForwardBody();
+
+  /** Create a new message that is a forward of this message, filling all
+    required header fields with the proper values. The returned message
+    is not stored in any folder. Marks this message as forwarded. */
+  KMMessage* createForward( const QString &tmpl = QString::null );
+
+  /** Create a new message that is a delivery receipt of this message,
+      filling required header fileds with the proper values. The
+      returned message is not stored in any folder. */
+  KMMessage* createDeliveryReceipt() const;
+
+  /** Create a new message that is a MDN for this message, filling all
+      required fields with proper values. The returned message is not
+      stored in any folder.
+
+      @param a Use AutomaticAction for filtering and ManualAction for
+               user-induced events.
+      @param d See docs for KMime::MDN::DispositionType
+      @param m See docs for KMime::MDN::DispositionModifier
+      @param allowGUI Set to true if this method is allowed to ask the
+                      user questions
+
+      @return The notification message or 0, if none should be sent.
+   **/
+  KMMessage* createMDN( KMime::MDN::ActionMode a,
+          KMime::MDN::DispositionType d,
+          bool allowGUI=false,
+          QValueList<KMime::MDN::DispositionModifier> m=QValueList<KMime::MDN::DispositionModifier>() );
+
+  /** Remove all headers but the content description ones, and those in the white list. */
+  void sanitizeHeaders( const QStringList& whiteList = QStringList() );
+
+  /** Parse the string and create this message from it. */
+  void fromDwString(const DwString& str, bool setStatus=false);
+  void fromString(const QCString& str, bool setStatus=false);
+  void fromByteArray(const QByteArray & ba, bool setStatus=false);
+
+  /** Return the entire message contents in the DwString. This function
+      is *fast* even for large message since it does *not* involve a
+      string copy.
+  */
+  const DwString& asDwString() const;
+  const DwMessage *asDwMessage();
+
+  /** Return the entire message contents as a string. This function is
+      slow for large message since it involves a string copy. If you
+      need the string representation only for a short time
+      (i.e. without the chance of calling any function in the
+      underlying mimelib, then you should use the asDwString function.
+      @see asDwString
+  */
+  QCString asString() const;
+
+  /**
+   * Return the message contents with the headers that should not be
+   * sent stripped off.
+   */
+  QByteArray asSendableString() const;
+
+  /**
+   * Return the message header with the headers that should not be
+   * sent stripped off.
+   */
+  QCString headerAsSendableString() const;
+
+  /**
+   * Remove all private header fields: *Status: and X-KMail-*
+   **/
+  void removePrivateHeaderFields();
+
+  /** Return reference to Content-Type header for direct manipulation. */
+  DwMediaType& dwContentType();
+
+  /** Return header as string. */
+  QString headerAsString() const;
+
+  /** Returns a decoded body part string to be further processed
+    by function asQuotedString().
+    THIS FUNCTION WILL BE REPLACED ONCE KMime IS FULLY INTEGRATED
+    (khz, June 05 2002)*/
+  void parseTextStringFromDwPart( partNode * root,
+                                          QCString& parsedString,
+                                          const QTextCodec*& codec,
+                                          bool& isHTML ) const;
+
+  /** Initialize header fields. Should be called on new messages
+    if they are not set manually. E.g. before composing. Calling
+    of setAutomaticFields(), see below, is still required. */
+  void initHeader(uint identity=0);
+
+  /** Initialize headers fields according to the identity and the transport
+    header of the given original message */
+  void initFromMessage(const KMMessage *msg, bool idHeaders = true);
+
+  /** @return the UOID of the identity for this message.
+      Searches the "x-kmail-identity" header and if that fails,
+      searches with KPIM::IdentityManager::identityForAddress()
+      and if that fails queries the KMMsgBase::parent() folder for a default.
+   **/
+  uint identityUoid() const;
+
+  /** Set the from, to, cc, bcc, encrytion etc headers as specified in the
+   * given identity. */
+  void applyIdentity( uint id );
+
+  /** Removes empty fields from the header, e.g. an empty Cc: or Bcc:
+    field. */
+  void cleanupHeader();
+
+  /** Set fields that are either automatically set (Message-id)
+    or that do not change from one message to another (MIME-Version).
+    Call this method before sending *after* all changes to the message
+    are done because this method does things different if there are
+    attachments / multiple body parts. */
+  void setAutomaticFields(bool isMultipart=false);
+
+  /** Get or set the 'Date' header field */
+  QString dateStr() const;
+  /** Returns the message date in asctime format or an empty string if the
+      message lacks a Date header. */
+  QCString dateShortStr() const;
+  QString dateIsoStr() const;
+  time_t date() const;
+  void setDate(const QCString& str);
+  void setDate(time_t aUnixTime);
+
+  /** Set the 'Date' header field to the current date. */
+  void setDateToday();
+
+  /** Get or set the 'To' header field */
+  QString to() const;
+  void setTo(const QString& aStr);
+  QString toStrip() const;
+
+  /** Get or set the 'ReplyTo' header field */
+  QString replyTo() const;
+  void setReplyTo( const QString &aStr );
+  void setReplyTo(KMMessage*);
+
+  /** Get or set the 'Cc' header field */
+  QString cc() const;
+  void setCc( const QString &aStr );
+  QString ccStrip() const;
+
+  /** Get or set the 'Bcc' header field */
+  QString bcc() const;
+  void setBcc( const QString &aStr );
+
+  /** Get or set the 'Fcc' header field */
+  QString fcc() const;
+  void setFcc( const QString &aStr );
+
+  /** Get or set the 'Drafts' folder */
+  QString drafts() const { return mDrafts; }
+  void setDrafts( const QString &aStr );
+
+  /** Get or set the 'Templates' folder */
+  QString templates() const { return mTemplates; }
+  void setTemplates( const QString &aStr );
+
+  /** Get or set the 'From' header field */
+  QString from() const;
+  void setFrom(const QString& aStr);
+  QString fromStrip() const;
+
+  /** @return The addr-spec of either the Sender: (if one is given) or
+   * the first addr-spec in From: */
+  QString sender() const;
+
+  /** Get or set the 'Who' header field. The actual field that is
+      returned depends on the contents of the owning folders whoField().
+      Usually this is 'From', but it can also contain 'To'. */
+  QString who() const;
+
+  /** Get or set the 'Subject' header field */
+  QString subject() const;
+  void setSubject(const QString& aStr);
+
+  /** Calculate strippedSubject */
+  void initStrippedSubjectMD5() {};
+
+  /** Get or set the 'X-Mark' header field */
+  QString xmark() const;
+  void setXMark(const QString& aStr);
+
+  /** Get or set the 'In-Reply-To' header field */
+  QString replyToId() const;
+  void setReplyToId(const QString& aStr);
+  QString replyToIdMD5() const;
+
+  /** Get the second to last id from the References header
+      field. If outgoing messages are not kept in the same
+      folder as incoming ones, this will be a good place to
+      thread the message beneath.
+      bob               <- second to last reference points to this
+       |_kmailuser      <- not in our folder, but Outbox
+           |_bob        <- In-Reply-To points to our mail above
+
+      Thread like this:
+      bob
+       |_bob
+
+      using replyToAuxIdMD5
+    */
+  QString replyToAuxIdMD5() const;
+
+  /**
+    Get a hash of the subject with all prefixes such as Re: removed.
+    Used for threading.
+  */
+  QString strippedSubjectMD5() const;
+
+  /**
+    Validate a list of email addresses, and also allow
+    aliases and distribution lists to be expanded
+    before validation.
+    @return Enum to describe the error.
+    @return brokenAddress the address that was faulty.
+    FIXME: this should be in libemailfucntions but that
+           requires moving expandAliases and all that
+           it brings
+  */
+  static KPIM::EmailParseResult isValidEmailAddressList( const QString& aStr,
+                                                         QString& brokenAddress );
+
+  /**
+    Get a hash of the subject.
+    Used for threading.
+  */
+  QString subjectMD5() const;
+
+  /** Is the subject prefixed by Re: or similar? */
+  bool subjectIsPrefixed() const;
+
+  /** Get or set the 'Message-Id' header field */
+  QString msgId() const;
+  void setMsgId(const QString& aStr);
+  QString msgIdMD5() const;
+
+  /** Get or set the references for this message */
+  QString references() const;
+  void setReferences(const QCString& aStr);
+
+  /** Returns the message ID, useful for followups */
+  QCString id() const;
+
+  /** Sets the message serial number. If defaulted to zero, the
+    serial number will be assigned using the dictionary. Note that
+    unless it is explicitely set the serial number will remain 0
+    as long as the mail is not in a folder. */
+  void setMsgSerNum(unsigned long newMsgSerNum = 0);
+
+  /** Returns the value of a header field with the given name. If multiple
+      header fields with the given name might exist then you should use
+      headerFields() instead.
+  */
+  QString headerField(const QCString& name) const;
+
+  enum HeaderFieldType { Unstructured, Structured, Address };
+
+  /** Set the header field with the given name to the given value.
+      If prepend is set to true, the header is inserted at the beginning
+      and does not overwrite an existing header field with the same name.
+  */
+  void setHeaderField( const QCString& name, const QString& value,
+                       HeaderFieldType type = Unstructured,
+                       bool prepend = false );
+
+  /** Returns a list of the values of all header fields with the given name. */
+  QStringList headerFields( const QCString& name ) const;
+
+  /** Returns the raw value of a header field with the given name. If multiple
+      header fields with the given name might exist then you should use
+      rawHeaderFields() instead.
+  */
+  QCString rawHeaderField( const QCString & name ) const;
+
+  /** Returns a list of the raw values of all header fields with the given
+      name.
+  */
+  QValueList<QCString> rawHeaderFields( const QCString & field ) const;
+
+  /** Splits the given address list into separate addresses. */
+  static KMime::Types::AddressList splitAddrField( const QCString & str );
+
+  /** Returns header address list as string list.
+      Valid for the following fields: To, Bcc, Cc, ReplyTo, ResentBcc,
+      ResentCc, ResentReplyTo, ResentTo */
+  KMime::Types::AddressList headerAddrField(const QCString& name) const;
+  KMime::Types::AddrSpecList extractAddrSpecs( const QCString & headerNames ) const;
+
+  /** Remove header field with given name */
+  void removeHeaderField(const QCString& name);
+
+  /** Remove all header fields with given name */
+  void removeHeaderFields(const QCString& name);
+
+  /** Get or set the 'Content-Type' header field
+      The member functions that involve enumerated types (ints)
+      will work only for well-known types or subtypes. */
+  QCString typeStr() const;
+  int type() const;
+  void setTypeStr(const QCString& aStr);
+  void setType(int aType);
+  /** Subtype */
+  QCString subtypeStr() const;
+  int subtype() const;
+  void setSubtypeStr(const QCString& aStr);
+  void setSubtype(int aSubtype);
+  /** add or change a parameter of a DwMediaType field */
+  static void setDwMediaTypeParam( DwMediaType &mType,
+                                   const QCString& attr,
+                                   const QCString& val );
+  /** add or change a parameter of the Content-Type field */
+  void setContentTypeParam(const QCString& attr, const QCString& val);
+
+  /** get the DwHeaders
+      (make sure to call setNeedsAssembly() function after directly
+       modyfying internal data like the headers) */
+  DwHeaders& headers() const;
+
+  /** tell the message that internal data were changed
+      (must be called after directly modifying message structures
+       e.g. when like changing header information by accessing
+       the header via headers() function) */
+  void setNeedsAssembly();
+
+  /** Get or set the 'Content-Transfer-Encoding' header field
+      The member functions that involve enumerated types (ints)
+      will work only for well-known encodings. */
+  QCString contentTransferEncodingStr() const;
+  int  contentTransferEncoding() const;
+  void setContentTransferEncodingStr(const QCString& aStr);
+  void setContentTransferEncoding(int aCte);
+
+  /** Cte is short for ContentTransferEncoding.
+      These functions are an alternative to the ones with longer names. */
+  QCString cteStr() const { return contentTransferEncodingStr(); }
+  int cte() const { return contentTransferEncoding(); }
+  void setCteStr(const QCString& aStr) { setContentTransferEncodingStr(aStr); }
+  void setCte(int aCte) { setContentTransferEncoding(aCte); }
+
+  /** Sets this body part's content to @p str. @p str is subject to
+      automatic charset and CTE detection.
+   **/
+  void setBodyFromUnicode( const QString & str );
+
+  /** Returns the body part decoded to unicode.
+   **/
+  QString bodyToUnicode(const QTextCodec* codec=0) const;
+
+  /** Get the message body. Does not decode the body. */
+  QCString body() const;
+
+  /** Set the message body. Does not encode the body. */
+  void setBody(const QCString& aStr);
+  void setBody(const DwString& aStr);
+  void setBody(const char* aStr); // avoid ambiguous calls
+
+  /** Hack to enable structured body parts to be set as flat text... */
+  void setMultiPartBody( const QCString & aStr );
+
+  /** Set the message body, encoding it according to the current content
+      transfer encoding. The first method for null terminated strings,
+      the second for binary data */
+  void setBodyEncoded(const QCString& aStr);
+  void setBodyEncodedBinary(const QByteArray& aStr);
+
+  /** Returns a list of content-transfer-encodings that can be used with
+      the given result of the character frequency analysis of a message or
+      message part under the given restrictions. */
+  static QValueList<int> determineAllowedCtes( const KMime::CharFreq& cf,
+                                               bool allow8Bit,
+                                               bool willBeSigned );
+
+  /** Sets body, encoded in the best fitting
+    content-transfer-encoding, which is determined by character
+    frequency count.
+
+    @param aBuf       input buffer
+    @param allowedCte return: list of allowed cte's
+    @param allow8Bit  whether "8bit" is allowed as cte.
+    @param willBeSigned whether "7bit"/"8bit" is allowed as cte according to RFC 3156
+  */
+  void setBodyAndGuessCte( const QByteArray& aBuf,
+                                   QValueList<int>& allowedCte,
+                                   bool allow8Bit = false,
+                                   bool willBeSigned = false );
+  void setBodyAndGuessCte( const QCString& aBuf,
+                                   QValueList<int>& allowedCte,
+                                   bool allow8Bit = false,
+                                   bool willBeSigned = false );
+
+  /** Returns a decoded version of the body from the current content transfer
+      encoding. The first method returns a null terminated string, the second
+      method is meant for binary data, not null is appended */
+  QCString bodyDecoded() const;
+  QByteArray bodyDecodedBinary() const;
+
+  /** Number of body parts the message has. This is one for plain messages
+      without any attachment. */
+  int numBodyParts() const;
+
+  /** Return the first DwBodyPart matching a given Content-Type
+      or zero, if no found. */
+  DwBodyPart * findDwBodyPart( int type, int subtype ) const;
+
+  /** Return the first DwBodyPart matching a given Content-Type
+      or zero, if no found. */
+  DwBodyPart * findDwBodyPart( const QCString& type, const QCString&  subtype ) const;
+
+  /** Return the first DwBodyPart matching a given partSpecifier
+      or zero, if no found. */
+  DwBodyPart* findDwBodyPart( DwBodyPart* part, const QString & partSpecifier );
+
+  /** Get the DwBodyPart at position in aIdx.  Indexing starts at 0.
+      If there is no body part at that index, return value will be zero. */
+  DwBodyPart * dwBodyPart( int aIdx ) const;
+
+  /** Get the number of the given DwBodyPart.
+      If no body part is given, return value will be -1. */
+  int partNumber( DwBodyPart * aDwBodyPart ) const;
+
+  /** Get the 1st DwBodyPart.
+      If there is no body part, return value will be zero. */
+  DwBodyPart * getFirstDwBodyPart() const;
+  DwMessage * getTopLevelPart() const { return mMsg; }
+
+  /** Fill the KMMessagePart structure for a given DwBodyPart.
+      If withBody is false the body of the KMMessagePart will be left
+      empty and only the headers of the part will be filled in*/
+  static void bodyPart(DwBodyPart* aDwBodyPart, KMMessagePart* aPart,
+          bool withBody = true );
+
+  /** Get the body part at position in aIdx.  Indexing starts at 0.
+      If there is no body part at that index, aPart will have its
+      attributes set to empty values. */
+  void bodyPart(int aIdx, KMMessagePart* aPart) const;
+
+  /** Compose a DwBodyPart (needed for adding a part to the message). */
+  DwBodyPart* createDWBodyPart(const KMMessagePart* aPart);
+
+  /** Append a DwBodyPart to the message. */
+  void addDwBodyPart(DwBodyPart * aDwPart);
+
+  /** Append a body part to the message. */
+  void addBodyPart(const KMMessagePart* aPart);
+
+  /** Delete all body parts. */
+  void deleteBodyParts();
+
+  /** Set "Status" and "X-Status" fields of the message from the
+   * internal message status. */
+  void setStatusFields();
+
+  /** Generates the Message-Id. It uses either the Message-Id suffix
+   * defined by the user or the given email address as suffix. The address
+   * must be given as addr-spec as defined in RFC 2822.
+   */
+  static QString generateMessageId( const QString& addr );
+
+  /** Convert '<' into "&lt;" resp. '>' into "&gt;" in order to
+    * prevent their interpretation by KHTML.
+    * Does *not* use the Qt replace function but runs a very fast C code
+    * the same way as lf2crlf() does.
+   */
+  static QCString html2source( const QCString & src );
+
+  /** Encodes an email address as mailto URL
+   */
+  static QString encodeMailtoUrl( const QString& str );
+
+  /** Decodes a mailto URL
+    */
+  static QString decodeMailtoUrl( const QString& url );
+
+  /** This function generates a displayable string from a list of email
+      addresses.
+      Input : mailbox-list
+      Output: comma separated list of display name resp. comment resp.
+              address
+  */
+  static QCString stripEmailAddr(const QCString& emailAddr);
+
+  /** Does the same as the above function. Shouldn't be used.
+   */
+  static QString stripEmailAddr(const QString& emailAddr);
+
+  /** Quotes the following characters which have a special meaning in HTML:
+   * '<'  '>'  '&'  '"'. Additionally '\\n' is converted to "<br />" if
+   * @p removeLineBreaks is false. If @p removeLineBreaks is true, then
+   * '\\n' is removed. Last but not least '\\r' is removed.
+   */
+  static QString quoteHtmlChars( const QString& str,
+                                 bool removeLineBreaks = false );
+
+  /** Converts the email address(es) to (a) nice HTML mailto: anchor(s).
+   * If stripped is TRUE then the visible part of the anchor contains
+   * only the name part and not the given emailAddr.
+   */
+  static QString emailAddrAsAnchor(const QString& emailAddr,
+          bool stripped=true, const QString& cssStyle = QString::null, bool link = true);
+
+  /** Strips an address from an address list. This is for example used
+      when replying to all.
+  */
+  static QStringList stripAddressFromAddressList( const QString& address,
+                                                  const QStringList& addresses );
+
+  /** Strips all the user's addresses from an address list. This is used
+      when replying.
+  */
+  static QStringList stripMyAddressesFromAddressList( const QStringList& list );
+
+  /** Returns true if the given address is contained in the given address list.
+  */
+  static bool addressIsInAddressList( const QString& address,
+                                      const QStringList& addresses );
+
+  /** Expands aliases (distribution lists and nick names) and appends a
+      domain part to all email addresses which are missing the domain part.
+  */
+  static QString expandAliases( const QString& recipients );
+
+  /** Uses the hostname as domain part and tries to determine the real name
+      from the entries in the password file.
+  */
+  static QString guessEmailAddressFromLoginName( const QString& userName );
+
+  /**
+   *  Given argument msg add quoting characters and relayout for max width maxLength
+   *  @param msg the string which it to be quoted
+   *  @param maxLineLength reformat text to be this amount of columns at maximum, adding
+   *    linefeeds at word boundaries to make it fit.
+   */
+  static QString smartQuote( const QString &msg, int maxLineLength );
+
+  /** Get the default message charset.*/
+  static QCString defaultCharset();
+
+  /** Get a list of preferred message charsets.*/
+  static const QStringList &preferredCharsets();
+
+  /** Replaces every occurrence of "${foo}" in @p s with headerField("foo") */
+  QString replaceHeadersInString( const QString & s ) const;
+
+  /** Get the message charset.*/
+  QCString charset() const;
+
+  /** Set the message charset. */
+  void setCharset(const QCString& aStr);
+
+  /** Get a QTextCodec suitable for this message part */
+  const QTextCodec * codec() const;
+
+  /** Set the charset the user selected for the message to display */
+  void setOverrideCodec( const QTextCodec* codec ) { mOverrideCodec = codec; }
+
+  /** Allow decoding of HTML for quoting */
+  void setDecodeHTML(bool aDecodeHTML)
+  { mDecodeHTML = aDecodeHTML; }
+
+  /** Reads config settings from group "KMMessage" and sets all internal
+   * variables (e.g. indent-prefix, etc.) */
+  static void readConfig();
+
+  /** Creates reference string for reply to messages.
+   *  reference = original first reference + original last reference + original msg-id
+   */
+  QCString getRefStr() const;
+
+  /** Get/set offset in mail folder. */
+  off_t folderOffset() const { return mFolderOffset; }
+  void setFolderOffset(off_t offs) { if(mFolderOffset != offs) { mFolderOffset=offs; setDirty(true); } }
+
+  /** Get/set filename in mail folder. */
+  QString fileName() const { return mFileName; }
+  void setFileName(const QString& file) { if(mFileName != file) { mFileName=file; setDirty(true); } }
+
+  /** Get/set size of message in the folder including the whole header in
+      bytes. Can be 0, if the message is not in a folder.
+      The setting of mMsgSize = mMsgLength = sz is needed for popFilter*/
+  size_t msgSize() const { return mMsgSize; }
+  void setMsgSize(size_t sz) { if(mMsgSize != sz) { mMsgSize = sz; setDirty(true); } }
+
+  /** Unlike the above function this works also, if the message is not in a
+      folder */
+  size_t msgLength() const
+    { return (mMsgLength) ? mMsgLength : mMsgSize; }
+  void setMsgLength(size_t sz) { mMsgLength = sz; }
+
+  /** Get/set size on server */
+  size_t msgSizeServer() const;
+  void setMsgSizeServer(size_t sz);
+
+  /** Get/set UID */
+  ulong UID() const;
+  void setUID(ulong uid);
+
+  /** Status of the message. */
+  KMMsgStatus status() const { return mStatus; }
+  /** Set status and mark dirty. */
+  void setStatus(const KMMsgStatus status, int idx = -1);
+  void setStatus(const char* s1, const char* s2=0) { KMMsgBase::setStatus(s1, s2); }
+
+  /** Set encryption status of the message. */
+  void setEncryptionState(const KMMsgEncryptionState, int idx = -1);
+
+  /** Set signature status of the message. */
+  void setSignatureState(const KMMsgSignatureState, int idx = -1);
+
+  void setMDNSentState( KMMsgMDNSentState status, int idx=-1 );
+
+  /** Encryption status of the message. */
+  KMMsgEncryptionState encryptionState() const { return mEncryptionState; }
+
+  /** Signature status of the message. */
+  KMMsgSignatureState signatureState() const { return mSignatureState; }
+
+  KMMsgMDNSentState mdnSentState() const { return mMDNSentState; }
+
+  /** Links this message to @p aMsg, setting link type to @p aStatus. */
+  void link(const KMMessage *aMsg, KMMsgStatus aStatus);
+  /** Returns the information for the Nth link into @p retMsg
+   * and @p retStatus. */
+  void getLink(int n, ulong *retMsgSerNum, KMMsgStatus *retStatus) const;
+
+  /** Convert wildcards into normal string */
+  QString formatString(const QString&) const;
+
+  /** Sets the body of the specified part */
+  void updateBodyPart(const QString partSpecifier, const QByteArray & data);
+
+  /** Returns the last DwBodyPart that was updated */
+  DwBodyPart* lastUpdatedPart() { return mLastUpdated; }
+
+  /** Return true if the complete message is available without referring to the backing store.*/
+  bool isComplete() const { return mComplete; }
+  /** Set if the message is a complete message */
+  void setComplete( bool v ) { mComplete = v; }
+
+  /** Return if the message is ready to be shown */
+  bool readyToShow() const { return mReadyToShow; }
+  /** Set if the message is ready to be shown */
+  void setReadyToShow( bool v ) { mReadyToShow = v; }
+
+  void updateAttachmentState(DwBodyPart * part = 0);
+
+  /** Return, if the message should not be deleted */
+  bool transferInProgress() const;
+  /** Set that the message shall not be deleted because it is still required */
+  void setTransferInProgress(bool value, bool force = false);
+
+  /** Returns an mbox message separator line for this message, i.e. a
+      string of the form
+      "From local@domain.invalid Sat Jun 12 14:00:00 2004\n".
+  */
+  QCString mboxMessageSeparator();
+
+  /** Returns message body with quoting header and indented by the
+    given indentation string. This is suitable for including the message
+    in another message of for replies, forwards. The header string is
+    a template where the following fields are replaced with the
+    corresponding values:
+    <pre>
+        %D: date of this message
+        %S: subject of this message
+        %F: sender (from) of this message
+        %%: a single percent sign
+    </pre>
+    No attachments are handled if includeAttach is false.
+    The signature is stripped if aStripSignature is true and
+    smart quoting is turned on. Signed or encrypted texts
+    get converted to plain text when allowDecryption is true. */
+  QString asQuotedString( const QString & headerStr,
+          const QString & indentStr,
+          const QString & selection=QString::null,
+          bool aStripSignature=true,
+          bool allowDecryption=true) const;
+
+  /** Return the textual content of the message as plain text,
+      converting HTML to plain text if necessary. */
+  QString asPlainText( bool stripSignature, bool allowDecryption ) const;
+
+  /** Get stored cursor position */
+  int getCursorPos() { return mCursorPos; };
+  /** Set cursor position as offset from message start */
+  void setCursorPos(int pos) { mCursorPos = pos; };
+
+  /** Get the KMMsgInfo object that was set with setMsgInfo(). */
+  KMMsgInfo* msgInfo() { return mMsgInfo; }
+  /** Set the KMMsgInfo object corresponding to this message. */
+  void setMsgInfo( KMMsgInfo* msgInfo ) { mMsgInfo = msgInfo; }
+
+  /* This is set in kmreaderwin if a message is being parsed to avoid
+     other parts of kmail (e.g. kmheaders) destroying the message.
+     Parsing can take longer and can be async (in case of gpg mails) */
+  bool isBeingParsed() const { return mIsParsed; }
+  void setIsBeingParsed( bool t ) { mIsParsed = t; }
+
+  /** Delete this message as soon as it no longer in use. */
+  void deleteWhenUnused();
+
+private:
+
+  /** Initialization shared by the ctors. */
+  void init( DwMessage* aMsg = 0 );
+  /** Assign the values of @param other to this message. Used in the copy c'tor. */
+  void assign( const KMMessage& other );
+
+  QString mDrafts;
+  QString mTemplates;
+  mutable DwMessage* mMsg;
+  mutable bool       mNeedsAssembly :1;
+  bool mDecodeHTML :1;
+  bool mReadyToShow :1;
+  bool mComplete :1;
+  bool mIsParsed : 1;
+  static const KMail::HeaderStrategy * sHeaderStrategy;
+  static QString sForwardStr;
+  const QTextCodec * mOverrideCodec;
+
+  QString mFileName;
+  off_t mFolderOffset;
+  size_t mMsgSize, mMsgLength;
+  time_t mDate;
+  KMMsgEncryptionState mEncryptionState;
+  KMMsgSignatureState mSignatureState;
+  KMMsgMDNSentState mMDNSentState;
+  KMMessage* mUnencryptedMsg;
+  DwBodyPart* mLastUpdated;
+  int mCursorPos;
+  KMMsgInfo* mMsgInfo; // used to remember the KMMsgInfo object this KMMessage replaced in the KMMsgList
+  static QValueList<KMMessage*> sPendingDeletes;
+};
+
+
+#endif /*kmmessage_h*/