// MIUTHDR.INL
//
// Copyright (c) 1998 Symbian Ltd.  All rights reserved. 
//

inline const TUint16 CImMultipartData::Version() const
	{
	return iVersion;
	}

inline void CImMultipartData::SetVersion( TUint16 aVersion )
	{
	iVersion = aVersion;
	}

inline void CImMultipartData::SetStart(const TMsvId aEntryId)
	{
	iStart = aEntryId;
	}

inline void CImMultipartData::AddElementL(const TDesC8& aURI, const TMsvId aEntryId)
	{
	iTypeArray->AppendL((TUint16)EDataTypeHTML);	// assume this is an HTML page (and not a link to URI elsewhere)
	iURIArray->AppendL(aURI);
	iEntryArray->AppendL(aEntryId);
	}

inline void CImMultipartData::AddElementL(const TImMultipartDataType& aType, const TDesC8& aURI, const TMsvId aEntryId)
	{
	iTypeArray->AppendL((TUint16)aType);
	iURIArray->AppendL(aURI);
	iEntryArray->AppendL(aEntryId);
	}

inline void CImMultipartData::AddElementL(const TImMultipartDataType& aType, const TMsvId aEntryId)
	{
	iTypeArray->AppendL((TUint16)aType);
	iURIArray->AppendL(TPtrC8());	// add empty element to keep all arrays in synch
	iEntryArray->AppendL(aEntryId);
	}

inline void CImMultipartData::AddElementL(const TMsvId aEntryId)
	{
	iEntryArray->AppendL(aEntryId);
	iURIArray->AppendL(TPtrC8());					// add empty element to keep all arrays in synch
	iTypeArray->AppendL((TUint16)EDataTypeUnknown);	// ditto - unknown entry data type
	}

inline TUint CImMultipartData::SetIndex(const TUint aIndex)
	{
	if (aIndex < (TUint) iEntryArray->Count())
		iIndex = aIndex;
	return Index();
	}
 
inline TMsvId CImMultipartData::Start() const
	{
	return iStart;
	}

inline TUint CImMultipartData::Index() const
	{
	return iIndex;
	}

inline TInt CImMultipartData::Count() const
	{
	return iEntryArray->Count();
	}

inline TMsvId CImMultipartData::CurrentEntryId() const
	{
	return iEntryArray->Count() ? (*iEntryArray)[iIndex] : KMsvNullIndexEntryId; 
	}

inline TPtrC8 CImMultipartData::CurrentURI() const
	{
	return iURIArray->Count() ? (*iURIArray)[iIndex] : TPtrC8(); 
	}

inline TImMultipartDataType CImMultipartData::CurrentType() const
	{
	return iTypeArray->Count() ? (TImMultipartDataType) (*iTypeArray)[iIndex] : EDataTypeUnknown; 
	}

inline TInt CImMultipartData::NextRecord()
	{
	// Increment to next array element while more array elements
	return SetIndex(iIndex+1);
	}




//----------------------------------------------------------------------------------------




inline void CImHeaderEncodingInfo::SetField(const TFieldList aField)
	{
	iField = aField;
	}

inline CImHeaderEncodingInfo::TFieldList CImHeaderEncodingInfo::Field() const
	{
	return iField;
	}

inline void CImHeaderEncodingInfo::SetOffset(const TInt aOffset)
	{
	iOffset = (TUint16)aOffset;
	}

inline TInt CImHeaderEncodingInfo::Offset() const
	{
	return iOffset;
	}

inline void CImHeaderEncodingInfo::SetLength(const TInt aLength)
	{
	iLength = (TUint16)aLength;
	}


inline TInt CImHeaderEncodingInfo::Length()  const
	{
	return iLength;
	}


inline void CImHeaderEncodingInfo::SetCharsetL(const TDesC8& aCharset)
	{
	HBufC8* newCharset = aCharset.AllocL();
	delete iCharset;
	iCharset = newCharset;
	}


inline TPtrC8 CImHeaderEncodingInfo::Charset() const
	{
	return iCharset ? TPtrC8(*iCharset) : TPtrC8();
	}


inline void CImHeaderEncodingInfo::SetEncodingType(const TDesC8& aChar)
	{
	// If invalid, defaults to QPEncoding
	if (aChar[0] == 'b' || aChar[0] == 'B')
		iType = CImHeaderEncodingInfo::EBase64;
	else if (aChar[0] == 'q' || aChar[0] == 'Q')
		iType = CImHeaderEncodingInfo::EQP;
	else
		iType = CImHeaderEncodingInfo::ENoEncoding;
	}

inline void CImHeaderEncodingInfo::SetEncodingType(const TEncodingType aType)
	{
	iType = aType;
	}

inline CImHeaderEncodingInfo::TEncodingType CImHeaderEncodingInfo::EncodingType()  const
	{
	return iType;
	}

inline void CImHeaderEncodingInfo::SetArrayValue(const TInt aValue)
	{
	iArrayValue = (TUint16)aValue;
	}


inline TInt CImHeaderEncodingInfo::ArrayValue()  const
	{
	return iArrayValue;
	}


inline void CImHeaderEncodingInfo::SetAddSpace(const TBool atrueFalse)
	{
	iAddSpace = atrueFalse;
	}


inline  TBool CImHeaderEncodingInfo::AddSpace() const
	{
	return iAddSpace;
	}

inline void CImHeaderEncodingInfo::SetEncodedLength(const TInt aLength)
	{
	iEncodedLength = (TInt8) aLength;
	}

inline TInt CImHeaderEncodingInfo::EncodedLength() const
	{
	return iEncodedLength + (AddSpace() ? 1 : 0);
	}

//----------------------------------------------------------------------------------------

inline CDesCArray& CImHeader::ToRecipients ()
	{
	return *iTo;
	}

inline CDesCArray& CImHeader::CcRecipients ()
	{
	return *iCc;
	}
	
inline CDesCArray& CImHeader::BccRecipients()
	{
	return *iBcc;
	}

inline const CDesCArray& CImHeader::ToRecipients () const 
	{
	return *iTo;
	}

inline const CDesCArray& CImHeader::CcRecipients () const
	{
	return *iCc;
	}
	
inline const CDesCArray& CImHeader::BccRecipients() const
	{
	return *iBcc;
	}

//-------------------------------------------------------------------------------------
//---------------------------- Used for forwarding an email ---------------------------

inline CDesCArray& CImHeader::ResentToRecipients ()
	{
	return *iResentTo;
	}

inline CDesCArray& CImHeader::ResentCcRecipients ()
	{
	return *iResentCc;
	}
	
inline CDesCArray& CImHeader::ResentBccRecipients()
	{
	return *iResentBcc;
	}

inline const CDesCArray& CImHeader::ResentToRecipients () const 
	{
	return *iResentTo;
	}

inline const CDesCArray& CImHeader::ResentCcRecipients () const
	{
	return *iResentCc;
	}
	
inline const CDesCArray& CImHeader::ResentBccRecipients() const
	{
	return *iResentBcc;
	}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------

inline const TUint CImHeader::RemoteSize() const
	{
	return iRemoteSize;
	}

inline void CImHeader::SetRemoteSize( TUint aRemoteSize )
	{
	iRemoteSize = aRemoteSize;
	}


inline const TUint16 CImHeader::Version() const
	{
	return iVersion;
	}

inline void CImHeader::SetVersion( TUint16 aVersion )
	{
	iVersion = aVersion;
	}

inline CArrayFix<CImHeaderEncodingInfo*>& CImHeader::EncodingInfo()
	{
	return *iEncodingInfo;
	}

inline const CArrayFix<CImHeaderEncodingInfo*>& CImHeader::EncodingInfo() const
	{
	return *iEncodingInfo;
	}

//////////////////////////////////////////////////////////////
//															//
//////////////////////////////////////////////////////////////


inline TBool TMsvEmailEntry::Encrypted() const
	{
	return iMtmData1&KMsvEmailEntryEncryptedFlag;
	}

inline void TMsvEmailEntry::SetEncrypted(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryEncryptedFlag) | (aFlag?KMsvEmailEntryEncryptedFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::Signed() const
	{
	return iMtmData1&KMsvEmailEntrySignedFlag;
	}

inline void TMsvEmailEntry::SetSigned(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntrySignedFlag) | (aFlag?KMsvEmailEntrySignedFlag:KMsvEmailEntryClearFlag);
	}

///
inline TBool TMsvEmailEntry::MHTMLEmail() const
	{
	return iMtmData1&KMsvEmailEntryMHTMLFlag;
	}

inline void TMsvEmailEntry::SetMHTMLEmail(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryMHTMLFlag) | (aFlag?KMsvEmailEntryMHTMLFlag:KMsvEmailEntryClearFlag);
	}


///
inline TBool TMsvEmailEntry::VCard() const
	{
	return iMtmData1&KMsvEmailEntryVCardFlag;
	}

inline void TMsvEmailEntry::SetVCard(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryVCardFlag) | (aFlag?KMsvEmailEntryVCardFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::VCalendar() const
	{
	return iMtmData1&KMsvEmailEntryVCalendarFlag;
	}

inline void TMsvEmailEntry::SetVCalendar(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryVCalendarFlag) | (aFlag?KMsvEmailEntryVCalendarFlag:KMsvEmailEntryClearFlag);
	}

//

inline TBool TMsvEmailEntry::Receipt() const
	{
	return iMtmData1&KMsvEmailEntryReceiptFlag;
	}

inline void TMsvEmailEntry::SetReceipt(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryReceiptFlag) | (aFlag?KMsvEmailEntryReceiptFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::UnreadIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4UnreadFlag;
	}

inline void TMsvEmailEntry::SetUnreadIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4UnreadFlag) | (aFlag?KMsvEmailEntryIMAP4UnreadFlag:KMsvEmailEntryClearFlag);
	SetUnread(aFlag);
	}


inline TBool TMsvEmailEntry::SeenIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4SeenFlag;
	}

inline void TMsvEmailEntry::SetSeenIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4SeenFlag) | (aFlag?KMsvEmailEntryIMAP4SeenFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::AnsweredIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4AnsweredFlag;
	}

inline void TMsvEmailEntry::SetAnsweredIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4AnsweredFlag) | (aFlag?KMsvEmailEntryIMAP4AnsweredFlag:KMsvEmailEntryClearFlag);
	}



inline TBool TMsvEmailEntry::FlaggedIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4FlaggedFlag;
	}

inline void TMsvEmailEntry::SetFlaggedIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4FlaggedFlag) | (aFlag?KMsvEmailEntryIMAP4FlaggedFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::DeletedIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4DeletedFlag;
	}

inline void TMsvEmailEntry::SetDeletedIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4DeletedFlag) | (aFlag?KMsvEmailEntryIMAP4DeletedFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::DraftIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4DraftFlag;
	}

inline void TMsvEmailEntry::SetDraftIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4DraftFlag) | (aFlag?KMsvEmailEntryIMAP4DraftFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::RecentIMAP4Flag() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4RecentFlag;
	}

inline void TMsvEmailEntry::SetRecentIMAP4Flag(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4RecentFlag) | (aFlag?KMsvEmailEntryIMAP4RecentFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::Mailbox() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4MailboxFlag;
	}

inline void TMsvEmailEntry::SetMailbox(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4MailboxFlag) | (aFlag?KMsvEmailEntryIMAP4MailboxFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::Orphan() const
	{
	return iMtmData1&KMsvEmailEntryOrphanFlag;
	}

inline void TMsvEmailEntry::SetOrphan(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryOrphanFlag) | (aFlag?KMsvEmailEntryOrphanFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::ValidUID() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4ValidUIDFlag;
	}

inline void TMsvEmailEntry::SetValidUID(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4ValidUIDFlag) | (aFlag?KMsvEmailEntryIMAP4ValidUIDFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::Subscribed() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4SubscribedFlag;
	}

inline void TMsvEmailEntry::SetSubscribed(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4SubscribedFlag) | (aFlag?KMsvEmailEntryIMAP4SubscribedFlag:KMsvEmailEntryClearFlag);
	}


inline TBool TMsvEmailEntry::LocalSubscription() const
	{
	return iMtmData1&KMsvEmailEntryIMAP4LocalSubFlag;
	}

inline void TMsvEmailEntry::SetLocalSubscription(TBool aFlag)
	{
	iMtmData1 = (iMtmData1 & ~KMsvEmailEntryIMAP4LocalSubFlag) | (aFlag?KMsvEmailEntryIMAP4LocalSubFlag:KMsvEmailEntryClearFlag);
	}


inline TUint32 TMsvEmailEntry::UID() const
	{
	return (TUint32)iMtmData2;	// hide the casting away from the caller
	}

inline void TMsvEmailEntry::SetUID(TUint32 aUID)
	{
	iMtmData2 = (TInt32) aUID;	// hide the casting away from the user
	}




//////////////////////////////////////////////////////////////
//				CImMimeHeader inlines						//
//////////////////////////////////////////////////////////////


inline const CDesC8Array& CImMimeHeader::ContentTypeParams() const 
	{
	return *iContentTypeParams;
	}


inline const CDesC8Array& CImMimeHeader::ContentDispositionParams() const
	{
	return *iContentDispositionParams;
	}


inline const CDesC8Array& CImMimeHeader::XTypeParams() const
	{
	return *iXTypeParams;
	}



inline CDesC8Array& CImMimeHeader::ContentTypeParams()
	{
	return *iContentTypeParams;
	}


inline CDesC8Array& CImMimeHeader::ContentDispositionParams()
	{
	return *iContentDispositionParams;
	}


inline CDesC8Array& CImMimeHeader::XTypeParams()
	{
	return *iXTypeParams;
	}


inline const TUint16 CImMimeHeader::Version() const
	{
	return iVersion;
	}

inline void CImMimeHeader::SetVersion( TUint16 aVersion )
	{
	iVersion = aVersion;
	}