/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of class CMessageHeader

*

*/

#include <CMsvAttachment.h>

#include <senduiconsts.h>

#include "messageheader.h"

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

// Two-phased constructor.

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

EXPORT_C CMessageHeader* CMessageHeader::NewL()

	{

	CMessageHeader* self = new(ELeave) CMessageHeader();

	return self;

	}

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

// Destructor

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

CMessageHeader::~CMessageHeader()

	{

	delete iSubject;

	delete iFrom;

	delete iMtmAsString;

	delete iPriAsString;

	}

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

//  C++  constructor.

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

CMessageHeader::CMessageHeader():

		iMtm(TUid(TUid::Null())),

		iMessageID(-1)

	{

	}

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

// Sets the unread flag

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

EXPORT_C void CMessageHeader::SetUnreadFlag(const TBool aUnread)

	{

	iUnread = aUnread;

	}

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

// Gets the unread flag

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

EXPORT_C void CMessageHeader::GetUnreadFlag(TBool& aUnread) const

	{

	aUnread = iUnread;

	}

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

// Gets the unread flag

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

EXPORT_C TBool CMessageHeader::UnreadFlag() const

	{

	return ( iUnread ? ETrue : EFalse ); 

	}

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

// Sets the attachment flag

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

EXPORT_C void CMessageHeader::SetAttachFlag(const TBool aAttachment)

	{

	iAttachment = aAttachment;

	}

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

// Gets the attachment flag

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

EXPORT_C void CMessageHeader::GetAttachFlag(TBool& aAttachment) const

	{

	aAttachment = iAttachment ; 

	}

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

// Gets the attachment flag

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

EXPORT_C TBool CMessageHeader::AttachFlag() const

	{

	return ( iAttachment ? ETrue : EFalse ); 

	}

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

// Sets the priority flag

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

EXPORT_C void CMessageHeader::SetPriorityFlag(const TMsvPriority aPriority)

	{

	iPriority = aPriority;

	delete iPriAsString;

	iPriAsString = NULL;

	switch ( iPriority )

		{

		case EMsvHighPriority: 

			iPriAsString = KPriorityHigh.operator()().Alloc();

			break;

		case EMsvLowPriority: 

			iPriAsString = KPriorityLow.operator()().Alloc();

			break;

		case EMsvMediumPriority:

		default:

			iPriAsString = KPriorityMedium.operator()().Alloc();

		}

	}

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

// Gets the priority flag

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

EXPORT_C void CMessageHeader::GetPriorityFlag(TMsvPriority& aPriority) const

	{

	aPriority = iPriority;

	}

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

// Gets the priority 

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

EXPORT_C TPtrC CMessageHeader::Priority() const

	{

    return iPriAsString ? TPtrC( *iPriAsString ) : TPtrC(); 

	}

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

// Sets the mtm id

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

EXPORT_C void CMessageHeader::SetMtmId(const TUid aMtm)

	{

	iMtm = aMtm;

	if ( iMtmAsString )

		delete iMtmAsString;

	iMtmAsString = NULL;

	if ( iMtm == KSenduiMtmSmsUid )

		{

		iMtmAsString = KMessageTypeSMS.operator()().Alloc();

		}

	else if ( iMtm == KSenduiMtmMmsUid )

		{

		iMtmAsString = KMessageTypeMMS.operator()().Alloc();

		}

	else

		{

		iMtmAsString = KUnknown.operator()().Alloc();

		}

	}

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

// Gets the mtm id

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

EXPORT_C void CMessageHeader::GetMtmId(TUid& aMtm) const

	{

	aMtm = iMtm;	

	}

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

// Gets the mtm 

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

EXPORT_C TPtrC CMessageHeader::Mtm() const

	{

    return iMtmAsString ? TPtrC( *iMtmAsString ) : TPtrC(); 

	}

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

// Sets the messge id

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

EXPORT_C void CMessageHeader::SetMessageId(const TMsvId aMessageID)

	{

	iMessageID = aMessageID;

	}

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

// Gets the messge id

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

EXPORT_C void CMessageHeader::GetMessageId(TMsvId& aMessageID) const

	{

	aMessageID = iMessageID;	

	}

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

// returns the messge id

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

EXPORT_C TMsvId CMessageHeader::MessageId() const

	{

	return iMessageID;	

	}

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

// Sets the time

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

EXPORT_C void CMessageHeader::SetTime(const TTime& aTime)

	{

	TDateTime tmp;

	tmp = aTime.DateTime();

	iTime = tmp;

	}

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

// Gets the time

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

EXPORT_C void CMessageHeader::GetTime(TTime& aTime) const

	{

	TDateTime tmp;

	tmp = iTime.DateTime();

	aTime = tmp;

	}

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

// Gets the time

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

EXPORT_C const TTime& CMessageHeader::Time() const

	{

	return iTime;

	}

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

// Sets the sender address

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

EXPORT_C void CMessageHeader::SetFromL(const TDesC& aFrom)

	{

	if( iFrom )

		{

		delete iFrom;

		iFrom = NULL;	

		}

	iFrom = aFrom.AllocL();	

	}

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

// Gets the sender address

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

EXPORT_C const TPtrC CMessageHeader::From() const

	{

    return iFrom ? TPtrC( *iFrom ) : TPtrC(); 

	}

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

// Sets the subject

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

EXPORT_C void CMessageHeader::SetSubjectL(const TDesC& aSubject)

	{

	if( iSubject )

		{

		delete iSubject;

		iSubject = NULL;	

		}

	iSubject = aSubject.AllocL();	

	}

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

// Gets the subject

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

EXPORT_C const TPtrC CMessageHeader::Subject() const

	{

    return iSubject ? TPtrC( *iSubject ) : TPtrC(); 

	}

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

// Two-phased constructor.

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

EXPORT_C CRecipientList* CRecipientList::CRecipientList::NewL()

	{

	CRecipientList* self = new (ELeave) CRecipientList;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// Destructor.

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

CRecipientList::~CRecipientList()

	{

	if ( iRecipients )

		iRecipients->Reset();

	delete iRecipients;

	iRecipientType.Close();

	}

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

// Constructor

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

CRecipientList::CRecipientList()

	{

	}

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

// SYmbian Constructor

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

void CRecipientList::ConstructL()

	{

	iRecipients = new (ELeave) CDesCArrayFlat(KArrayGranularity);	

	}

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

// Appends the recipient type 

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

EXPORT_C void CRecipientList::AppendL(TMsvRecipientType aValue, const TDesC& aPtr)

	{

	iRecipientType.AppendL(aValue);

	TRAPD(err, iRecipients->AppendL(aPtr));

	if (err != KErrNone)

		{

		iRecipientType.Remove(iRecipientType.Count() - 1);

		User::Leave(err);

		}

	}

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

// Gives the number of recipients

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

EXPORT_C TInt CRecipientList::Count() const

	{

	return iRecipients->Count();

	}

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

// Gives the recipient type

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

EXPORT_C TMsvRecipientType CRecipientList::Type(TInt aPos) const

	{

	return iRecipientType[aPos];

	}

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

// Gives recipient address

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

EXPORT_C const TDesC& CRecipientList::operator[](TInt aIndex) const

	{

	HBufC16* temp=(*(HBufC16**)iRecipients->At(aIndex));

	return *temp;

	}

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

// Resets the recipient list

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

EXPORT_C void CRecipientList::Reset()

	{

	iRecipients->Reset();

	iRecipientType.Reset();

	}

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

// Two Phase Constructor

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

EXPORT_C CFilterParamInfo* CFilterParamInfo::NewL()

	{

	return new(ELeave) CFilterParamInfo;

	}

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

// Destructor

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

CFilterParamInfo::~CFilterParamInfo()

	{

	Reset();

	}

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

// Constructor

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

CFilterParamInfo::CFilterParamInfo()

	{

	}

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

// Sets the sender address as a filter

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

EXPORT_C void CFilterParamInfo::AddFromL( const TDesC& aFrom )

	{

	if( !iFromArray )

		{

		iFromArray = new (ELeave) CDesCArraySeg( KArrayGranularity );

		}

	if ( aFrom.Length() )

		{

		iFromArray->AppendL( aFrom );	

		iFilter |= EFilterFrom;

		}

	}

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

// Gets the sender address as a filter

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

EXPORT_C const CDesCArray* CFilterParamInfo::From() const 

	{

	return iFromArray;

	}

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

// Sets the mtm as a filter

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

EXPORT_C TInt CFilterParamInfo::AddMtmL( const TDesC& aMtm )

	{

	if ( aMtm.CompareF( KMessageTypeSMS ) == 0 || aMtm.CompareF( KMessageTypeMMS ) == 0 )

		{

		}

	else

		{

		return KErrNotSupported;

		}

	if( !iMtmArray )

		{

		iMtmArray = new (ELeave) CDesCArraySeg( KArrayGranularity );

		}

	if ( aMtm.Length() )

		{

		iMtmArray->AppendL( aMtm );	

		iFilter |= EFilterMtm;

		}

	return KErrNone;	

	}

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

// Gets the mtm array

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

EXPORT_C const CDesCArray* CFilterParamInfo::Mtm() const

	{

	return iMtmArray;

	}

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

// Sets subject filter

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

EXPORT_C void CFilterParamInfo::SetSubjectL( const TDesC& aSubject )

	{

	if ( iSubject )

		{

		delete iSubject;

		iSubject = NULL;

		iFilter ^= ( iFilter & EFilterSubject );

		}

	if ( aSubject.Length() )

		{

		iSubject = HBufC::NewL( aSubject.Length() );

		iSubject->Des().Copy( aSubject );

		iFilter |= EFilterSubject;

		}

	}

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

// Gets the filter for subject of message

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

EXPORT_C TPtrC CFilterParamInfo::Subject() const

	{

    return iSubject ? TPtrC( *iSubject ) : TPtrC(); 

	}

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

// Sets the sorting order

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

EXPORT_C void CFilterParamInfo::SetSortType( const TMsvSorting aSortType )

	{

    iSortType = aSortType;   

	}

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

// Gets the sorting order

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

EXPORT_C TMsvSorting CFilterParamInfo::SortType() const

	{

	return iSortType;

	}

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

// Sets the message id as filter

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

EXPORT_C void CFilterParamInfo::SetMessageIdFilter( const TMsvId aMessageId )

	{

	iFilter ^= ( iFilter & EFilterId );

	if( aMessageId != 0)

		{

		iMessageId = aMessageId;

		iFilter |= EFilterId;

		}

	}

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

// Gets the message id as filter

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

EXPORT_C TMsvId CFilterParamInfo::MessageId() const

	{

	return iMessageId;

	}

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

// Sets the starting date for date range as a filter

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

EXPORT_C void CFilterParamInfo::SetStartDateFilter( const TTime& aStartDate )

	{

	iFilter ^= ( iFilter & EFilterStartDate );

	if ( aStartDate.Int64() > 0 )