kmmessage.h

/* kmmessage.h: Mime Message Class
 *
 */
#ifndef kmmessage_h
#define kmmessage_h
 
// 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 TQValueList;
 
class TQStringList;
class TQString;
class TQTextCodec;
class TQStrList;
 
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 TQValueList<Address> AddressList;
    typedef TQValueList<AddrSpec> AddrSpecList;
  }
}
 
namespace KMail {
  class HeaderStrategy;
}
 
class DwEntity;
class DwBodyPart;
class DwMediaType;
class DwHeaders;
 
class partNode;
 
namespace KMail {
  enum ReplyStrategy { ReplySmart = 0,
                       ReplyAuthor,
                       ReplyList,
                       ReplyAll,
                       ReplyNone };
}
 
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.
 
  KMMessage(KMFolder* parent=0);
 
  KMMessage(DwMessage*);
 
  KMMessage(KMMsgInfo& msgInfo);
 
  KMMessage( const KMMessage& other );
 
#if 0 // currently unused
  const KMMessage& operator=( const KMMessage& other ) {
    if( &other == this )
      return *this;
    assign( other );
    return *this;
  }
#endif
 
  virtual ~KMMessage();
 
  KMMsgBase & toMsgBase() { return *this; }
  const KMMsgBase & toMsgBase() const { return *this; }
 
  bool isMessage() const;
 
  bool isUrgent() const;
 
  void setUnencryptedMsg( KMMessage* unencrypted );
 
  bool hasUnencryptedMsg() const { return 0 != mUnencryptedMsg; }
 
  KMMessage* unencryptedMsg() const { return mUnencryptedMsg; }
 
  KMMessage* takeUnencryptedMsg()
  {
    KMMessage* ret = mUnencryptedMsg;
    mUnencryptedMsg = 0;
    return ret;
  }
 
  void del() { setStatus(KMMsgStatusDeleted); }
 
  void undel() { setStatus(KMMsgStatusOld); }
 
  void touch() { setStatus(KMMsgStatusOld); }
 
  KMMessage* createReply( KMail::ReplyStrategy replyStrategy = KMail::ReplySmart,
                          TQString selection=TQString(), bool noQuote = false,
                          bool allowDecryption = true,
                          const TQString &tmpl = TQString(),
                          const TQString &originatingAccount = TQString() );
 
  KMMessage* createRedirect( const TQString &toStr );
 
  TQCString createForwardBody();
 
  KMMessage* createForward( const TQString &tmpl = TQString() );
 
  KMMessage* createDeliveryReceipt() const;
 
  KMMessage* createMDN( KMime::MDN::ActionMode a,
          KMime::MDN::DispositionType d,
          bool allowGUI=false,
          TQValueList<KMime::MDN::DispositionModifier> m=TQValueList<KMime::MDN::DispositionModifier>() );
 
  void sanitizeHeaders( const TQStringList& whiteList = TQStringList() );
 
  void fromDwString(const DwString& str, bool setStatus=false);
  void fromString(const TQCString& str, bool setStatus=false);
  void fromByteArray(const TQByteArray & ba, bool setStatus=false);
 
  const DwString& asDwString() const;
  const DwMessage *asDwMessage();
 
  TQCString asString() const;
 
  TQByteArray asSendableString() const;
 
  TQCString headerAsSendableString() const;
 
  void removePrivateHeaderFields();
 
  DwMediaType& dwContentType();
 
  TQString headerAsString() const;
 
  void parseTextStringFromDwPart( partNode * root,
                                          TQCString& parsedString,
                                          const TQTextCodec*& codec,
                                          bool& isHTML ) const;
 
  void initHeader(uint identity=0);
 
  void initFromMessage(const KMMessage *msg, bool idHeaders = true);
 
  uint identityUoid() const;
 
  void applyIdentity( uint id );
 
  void cleanupHeader();
 
  void setAutomaticFields(bool isMultipart=false);
 
  TQString dateStr() const;
  TQCString dateShortStr() const;
  TQString dateIsoStr() const;
  time_t date() const;
  void setDate(const TQCString& str);
  void setDate(time_t aUnixTime);
 
  void setDateToday();
 
  TQString to() const;
  void setTo(const TQString& aStr);
  TQString toStrip() const;
 
  TQString replyTo() const;
  void setReplyTo( const TQString &aStr );
  void setReplyTo(KMMessage*);
 
  TQString cc() const;
  void setCc( const TQString &aStr );
  TQString ccStrip() const;
 
  TQString bcc() const;
  void setBcc( const TQString &aStr );
 
  TQString fcc() const;
  void setFcc( const TQString &aStr );
 
  TQString drafts() const { return mDrafts; }
  void setDrafts( const TQString &aStr );
 
  TQString templates() const { return mTemplates; }
  void setTemplates( const TQString &aStr );
 
  TQString from() const;
  void setFrom(const TQString& aStr);
  TQString fromStrip() const;
 
  TQString sender() const;
 
  TQString who() const;
 
  TQString subject() const;
  void setSubject(const TQString& aStr);
 
  void initStrippedSubjectMD5() {};
 
  TQString xmark() const;
  void setXMark(const TQString& aStr);
 
  TQString replyToId() const;
  void setReplyToId(const TQString& aStr);
  TQString replyToIdMD5() const;
 
  TQString replyToAuxIdMD5() const;
 
  TQString strippedSubjectMD5() const;
 
  static KPIM::EmailParseResult isValidEmailAddressList( const TQString& aStr,
                                                         TQString& brokenAddress );
 
  TQString subjectMD5() const;
 
  bool subjectIsPrefixed() const;
 
  TQString msgId() const;
  void setMsgId(const TQString& aStr);
  TQString msgIdMD5() const;
 
  TQString references() const;
  void setReferences(const TQCString& aStr);
 
  TQCString id() const;
 
  void setMsgSerNum(unsigned long newMsgSerNum = 0);
 
  TQString headerField(const TQCString& name) const;
 
  enum HeaderFieldType { Unstructured, Structured, Address };
 
  void setHeaderField( const TQCString& name, const TQString& value,
                       HeaderFieldType type = Unstructured,
                       bool prepend = false );
 
  TQStringList headerFields( const TQCString& name ) const;
 
  TQCString rawHeaderField( const TQCString & name ) const;
 
  TQValueList<TQCString> rawHeaderFields( const TQCString & field ) const;
 
  static KMime::Types::AddressList splitAddrField( const TQCString & str );
 
  KMime::Types::AddressList headerAddrField(const TQCString& name) const;
  KMime::Types::AddrSpecList extractAddrSpecs( const TQCString & headerNames ) const;
 
  void removeHeaderField(const TQCString& name);
 
  void removeHeaderFields(const TQCString& name);
 
  TQCString typeStr() const;
  int type() const;
  void setTypeStr(const TQCString& aStr);
  void setType(int aType);
  TQCString subtypeStr() const;
  int subtype() const;
  void setSubtypeStr(const TQCString& aStr);
  void setSubtype(int aSubtype);
  static void setDwMediaTypeParam( DwMediaType &mType,
                                   const TQCString& attr,
                                   const TQCString& val );
  void setContentTypeParam(const TQCString& attr, const TQCString& val);
 
  DwHeaders& headers() const;
 
  void setNeedsAssembly();
 
  void assembleIfNeeded();
 
  TQCString contentTransferEncodingStr() const;
  int contentTransferEncoding( DwEntity *entity = 0 ) const;
  void setContentTransferEncodingStr( const TQCString& cteString, DwEntity *entity = 0 );
  void setContentTransferEncoding( int cte, DwEntity *entity = 0 );
 
  TQCString cteStr() const { return contentTransferEncodingStr(); }
  int cte( DwEntity *entity = 0 ) const { return contentTransferEncoding( entity ); }
  void setCteStr( const TQCString& aStr, DwEntity *entity = 0 ) {
    setContentTransferEncodingStr( aStr, entity );
  }
  void setCte( int aCte, DwEntity *entity = 0 ) {
    setContentTransferEncoding( aCte, entity );
  }
 
  void setBodyFromUnicode( const TQString & str, DwEntity *entity = 0 );
 
  TQString bodyToUnicode(const TQTextCodec* codec=0) const;
 
  TQCString body() const;
 
  void setBody(const TQCString& aStr);
  void setBody(const DwString& aStr);
  void setBody(const char* aStr); // avoid ambiguous calls
 
  void setMultiPartBody( const TQCString & aStr );
 
  void setBodyEncoded( const TQCString& aStr, DwEntity *entity = 0 );
  void setBodyEncodedBinary( const TQByteArray& aStr, DwEntity *entity = 0 );
 
  static TQValueList<int> determineAllowedCtes( const KMime::CharFreq& cf,
                                               bool allow8Bit,
                                               bool willBeSigned );
 
  void setBodyAndGuessCte( const TQByteArray& aBuf, TQValueList<int>& allowedCte,
                           bool allow8Bit = false,
                           bool willBeSigned = false,
                           DwEntity *entity = 0 );
 
  void setBodyAndGuessCte( const TQCString& aBuf,
                           TQValueList<int>& allowedCte,
                           bool allow8Bit = false,
                           bool willBeSigned = false,
                           DwEntity *entity = 0 );
 
  TQCString bodyDecoded() const;
  TQByteArray bodyDecodedBinary() const;
 
  int numBodyParts() const;
 
  DwBodyPart * findDwBodyPart( int type, int subtype ) const;
 
  DwBodyPart * findDwBodyPart( const TQCString& type, const TQCString&  subtype ) const;
 
  DwBodyPart* findDwBodyPart( DwBodyPart* part, const TQString & partSpecifier );
 
  DwBodyPart * dwBodyPart( int aIdx ) const;
 
  int partNumber( DwBodyPart * aDwBodyPart ) const;
 
  DwBodyPart * getFirstDwBodyPart() const;
  DwMessage * getTopLevelPart() const { return mMsg; }
 
  static void bodyPart(DwBodyPart* aDwBodyPart, KMMessagePart* aPart,
          bool withBody = true );
 
  void bodyPart(int aIdx, KMMessagePart* aPart) const;
 
  DwBodyPart* createDWBodyPart(const KMMessagePart* aPart);
 
  void addDwBodyPart(DwBodyPart * aDwPart);
 
  void addBodyPart(const KMMessagePart* aPart);
 
  void deleteBodyParts();
 
  bool deleteBodyPart( int partIndex );
 
  void setStatusFields();
 
  static TQString generateMessageId( const TQString& addr );
 
  static TQCString html2source( const TQCString & src );
 
  static TQString encodeMailtoUrl( const TQString& str );
 
  static TQString decodeMailtoUrl( const TQString& url );
 
  static TQCString stripEmailAddr(const TQCString& emailAddr);
 
  static TQString stripEmailAddr(const TQString& emailAddr);
 
  static TQString quoteHtmlChars( const TQString& str,
                                 bool removeLineBreaks = false );
 
  static TQString emailAddrAsAnchor(const TQString& emailAddr,
          bool stripped=true, const TQString& cssStyle = TQString(), bool link = true);
 
  static TQStringList stripAddressFromAddressList( const TQString& address,
                                                  const TQStringList& addresses );
 
  static TQStringList stripMyAddressesFromAddressList( const TQStringList& list );
 
  static bool addressIsInAddressList( const TQString& address,
                                      const TQStringList& addresses );
 
  static TQString expandAliases( const TQString& recipients );
 
  static TQString guessEmailAddressFromLoginName( const TQString& userName );
 
  static TQString smartQuote( const TQString &msg, int maxLineLength );
 
  static TQCString defaultCharset();
 
  static const TQStringList &preferredCharsets();
 
  TQString replaceHeadersInString( const TQString & s ) const;
 
  TQCString charset() const;
 
  void setCharset( const TQCString& charset, DwEntity *entity = 0 );
 
  const TQTextCodec * codec() const;
 
  void setOverrideCodec( const TQTextCodec* codec ) { mOverrideCodec = codec; }
 
  void setDecodeHTML(bool aDecodeHTML)
  { mDecodeHTML = aDecodeHTML; }
 
  static void readConfig();
 
  TQCString getRefStr() const;
 
  off_t folderOffset() const { return mFolderOffset; }
  void setFolderOffset(off_t offs) { if(mFolderOffset != offs) { mFolderOffset=offs; setDirty(true); } }
 
  TQString fileName() const { return mFileName; }
  void setFileName(const TQString& file) { if(mFileName != file) { mFileName=file; setDirty(true); } }
 
  TQString originatingAccountName() const { return mOriginatingAccountName; }
  void setOriginatingAccountName(const TQString& account) { if(mOriginatingAccountName != account) { mOriginatingAccountName=account; setDirty(true); } }
 
  size_t msgSize() const { return mMsgSize; }
  void setMsgSize(size_t sz) { if(mMsgSize != sz) { mMsgSize = sz; setDirty(true); } }
 
  size_t msgLength() const
    { return (mMsgLength) ? mMsgLength : mMsgSize; }
  void setMsgLength(size_t sz) { mMsgLength = sz; }
 
  size_t msgSizeServer() const;
  void setMsgSizeServer(size_t sz);
 
  ulong UID() const;
  void setUID(ulong uid);
 
  KMMsgStatus status() const { return mStatus; }
  void setStatus(const KMMsgStatus status, int idx = -1);
  void setStatus(const char* s1, const char* s2=0) { KMMsgBase::setStatus(s1, s2); }
 
  void setEncryptionState(const KMMsgEncryptionState, int idx = -1);
 
  void setSignatureState(const KMMsgSignatureState, int idx = -1);
 
  void setMDNSentState( KMMsgMDNSentState status, int idx=-1 );
 
  KMMsgEncryptionState encryptionState() const { return mEncryptionState; }
 
  KMMsgSignatureState signatureState() const { return mSignatureState; }
 
  KMMsgMDNSentState mdnSentState() const { return mMDNSentState; }
 
  void link(const KMMessage *aMsg, KMMsgStatus aStatus);
  void getLink(int n, ulong *retMsgSerNum, KMMsgStatus *reStatus) const;
 
  TQString formatString(const TQString&) const;
 
  void updateBodyPart(const TQString partSpecifier, const TQByteArray & data);
 
  DwBodyPart* lastUpdatedPart() { return mLastUpdated; }
 
  bool isComplete() const { return mComplete; }
  void setComplete( bool v ) { mComplete = v; }
 
  bool readyToShow() const { return mReadyToShow; }
  void setReadyToShow( bool v ) { mReadyToShow = v; }
 
  void updateAttachmentState( DwBodyPart *part = 0 );
  void updateInvitationState();
 
  bool transferInProgress() const;
  void setTransferInProgress(bool value, bool force = false);
 
  TQCString mboxMessageSeparator();
 
  TQString asQuotedString( const TQString & headerStr,
          const TQString & indentStr,
          const TQString & selection=TQString(),
          bool aStripSignature=true,
          bool allowDecryption=true) const;
 
  TQString asPlainText( bool stripSignature, bool allowDecryption ) const;
 
  TQString asPlainTextFromObjectTree( partNode *root, bool stripSignature,
                                     bool allowDecryption ) const;
 
  int getCursorPos() { return mCursorPos; };
  void setCursorPos(int pos) { mCursorPos = pos; };
 
  KMMsgInfo* msgInfo() { return mMsgInfo; }
  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; }
 
  void deleteWhenUnused();
 
  DwBodyPart* findPart( int index );
 
private:
 
  void init( DwMessage* aMsg = 0 );
  void assign( const KMMessage& other );
 
  DwBodyPart* findPartInternal( DwEntity* root, int index, int &accu );
 
  TQString mDrafts;
  TQString 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 TQString sForwardStr;
  const TQTextCodec * mOverrideCodec;
 
  TQString mFileName;
  TQString mOriginatingAccountName;
  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 TQValueList<KMMessage*> sPendingDeletes;
};
 
 
#endif /*kmmessage_h*/