kmmessage.h

// -*- mode: C++; c-file-style: "gnu" -*-
/* 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*/