summaryrefslogtreecommitdiffstats
path: root/kmail/kmmessage.h
diff options
context:
space:
mode:
Diffstat (limited to 'kmail/kmmessage.h')
-rw-r--r--kmail/kmmessage.h916
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*/