/*

* 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:  

*

*/

#include <calentry.h>

#include <calrrule.h>

#include <caluser.h>

#include "entryattributes.h"

#include "calendarconstants.h"

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

// CAttendeeInfo::NewL

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

//

EXPORT_C CAttendeeInfo* CAttendeeInfo::NewL( const TDesC& aAddress )

	{

	CAttendeeInfo* self = new (ELeave) CAttendeeInfo;

	CleanupStack::PushL( self );

	self->ConstructL( aAddress );

	CleanupStack::Pop( self );

	return self;

	}

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

// Constructor

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

//

CAttendeeInfo::CAttendeeInfo()

	{

	iResponse = EFalse;

	}	

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

// 2nd-phased constructor of two phase construction

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

//

void CAttendeeInfo::ConstructL( const TDesC& aAddress )

	{

	if( aAddress.Length() )

		{

		iAddress = aAddress.AllocL();

		}

	else

		User::Leave(KErrArgument);

	}

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

// Destructor

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

//	

CAttendeeInfo::~CAttendeeInfo()

	{

	delete iAddress;

	delete iCommonName;

	delete iRole;

	delete iStatus;

	}	

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

// CAttendeeInfo::SetCommonNameL

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

//

EXPORT_C void CAttendeeInfo::SetCommonNameL( const TDesC& aName )

	{

	if( aName.Length() )

		{

		iCommonName = aName.AllocL();

		}

	}

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

// CAttendeeInfo::SetRoleL

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

//

EXPORT_C void CAttendeeInfo::SetRoleL( const TDesC& aRole )

	{

	if( aRole.Length() )

		{

		iRole = aRole.AllocL();

		}

	}

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

// CAttendeeInfo::SetStatusL

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

//

EXPORT_C void CAttendeeInfo::SetStatusL( const TDesC& aStatus )

	{

	if( aStatus.Length() )

		{

		iStatus = aStatus.AllocL();

		}

	}

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

// CAttendeeInfo::SetRsvp

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

//

EXPORT_C void CAttendeeInfo::SetRsvp( const TBool aResponse )

	{

	iResponse = aResponse;	

	}

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

// CAttendeeInfo::Address

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

//

EXPORT_C TPtrC CAttendeeInfo::Address()

	{

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

	}

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

// CAttendeeInfo::CommonName

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

//

EXPORT_C TPtrC CAttendeeInfo::CommonName()

	{

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

	}

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

// CAttendeeInfo::Role

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

//

EXPORT_C TPtrC CAttendeeInfo::Role()

	{

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

	}

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

// CAttendeeInfo::Statuse

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

//

EXPORT_C TPtrC CAttendeeInfo::Status()

	{

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

	}

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

// CAttendeeInfo::ResponseRequested

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

//

EXPORT_C TBool CAttendeeInfo::ResponseRequested()

	{

	return iResponse;	

	}

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

// CRepeatInfo::NewL

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

//

EXPORT_C CRepeatInfo* CRepeatInfo::NewL( const TInt aType )

	{

	CRepeatInfo* self = new (ELeave) CRepeatInfo;

	CleanupStack::PushL( self );

	self->ConstructL( aType );

	CleanupStack::Pop( self );

	return self;

	}

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

// Constructor

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

//

CRepeatInfo::CRepeatInfo()

	{

	iInterval = 1;

	iType = TCalRRule::EInvalid;

	}	

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

// 2nd-phased constructor of two phase construction

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

//

void CRepeatInfo::ConstructL( const TInt aType )

	{

	if ( aType == KRRTypeDaily )

		iType = TCalRRule::EDaily;

	else if ( aType == KRRTypeWeekly )

		iType = TCalRRule::EWeekly;

	else if ( aType == KRRTypeMonthly )

		iType = TCalRRule::EMonthly;

	else if ( aType == KRRTypeYearly )

		iType = TCalRRule::EYearly;

	else

		User::Leave(KErrArgument);	

	iRule.SetType( iType );

	}

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

// Destructor

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

//

CRepeatInfo::~CRepeatInfo()

	{

	iMonthDays.Close();

	iMonthDates.Close();

	iWeekDays.Close();

	}

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

// CRepeatInfo::SetCount

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

//

EXPORT_C void CRepeatInfo::SetCount( const TUint aCount )

	{

	iRule.SetCount( aCount );

	}

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

// CRepeatInfo::SetUntilTimeL

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

//

EXPORT_C void CRepeatInfo::SetUntilTimeL( const TTime& aUntilTime )

	{

	if( aUntilTime < TCalTime::MinTime() || aUntilTime > TCalTime::MaxTime() )

		User::Leave( KErrArgument );

	iUntilTime.SetTimeUtcL( aUntilTime );	

	iRule.SetUntil( iUntilTime );

	}

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

// CRepeatInfo::SetStartTimeL

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

//

EXPORT_C void CRepeatInfo::SetStartTimeL( const TTime& aStartTime )

	{

	if( aStartTime < TCalTime::MinTime() || aStartTime > TCalTime::MaxTime() )

		User::Leave( KErrArgument );

	iStartTime.SetTimeUtcL( aStartTime );	

	iRule.SetDtStart( iStartTime );

	}

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

// CRepeatInfo::SetInterval

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

//		

EXPORT_C void CRepeatInfo::SetInterval( const TInt aInterval )

	{

	iInterval = aInterval;	

	iRule.SetInterval( iInterval );

	}

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

// CRepeatInfo::SetDaysInWeek

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

//

EXPORT_C void CRepeatInfo::SetDaysInWeek( const RArray<TDay>& aDays )

	{

	if( iType == TCalRRule::EWeekly )

		{

		for( int i=0 ; i<aDays.Count() ; i++)

			iWeekDays.Append( aDays[i] );

		iRule.SetByDay( iWeekDays );

		}

	}

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

// CRepeatInfo::SetMonthDates

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

//

EXPORT_C void CRepeatInfo::SetMonthDates( const RArray<TInt>& aMonthDates  )

	{

	if( iType == TCalRRule::EMonthly )

		{

		// sets the month dates for the monthly repeat

		for( int i=0 ; i<aMonthDates.Count() ; i++)

			iMonthDates.Append( aMonthDates[i] );

		iRule.SetByMonthDay( iMonthDates );

		}

	}

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

// CRepeatInfo::SetMonthDays

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

//

EXPORT_C void CRepeatInfo::SetMonthDays( const RArray<TCalRRule::TDayOfMonth>& aDays )

	{

	if( iType == TCalRRule::EMonthly || iType == TCalRRule::EYearly )

		{

		TInt count = aDays.Count();

		// sets the days of the month for monthly and yearly repeats

		for( TInt i=0 ; i < count ; i++)

			{

			iMonthDays.Append( aDays[i] );

			}

		iRule.SetByDay( iMonthDays );	

		}

	}

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

// CRepeatInfo::SetMonth

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

//

EXPORT_C void CRepeatInfo::SetMonth( const TInt aMonth)

	{

	// sets the month for a yearly repeat

	if( iType == TCalRRule::EYearly )

		{

		iMonth = TMonth( aMonth );

    		RArray<TMonth> monthList;

		monthList.Append( iMonth );

		iRule.SetByMonth( monthList );

		}	

    	}

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

// CRepeatInfo::SetWeekStart

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

//

EXPORT_C void CRepeatInfo::SetWeekStart( const TInt aDay )

	{

	iWkSt = TDay( aDay );

	iRule.SetWkSt( iWkSt );	

	}

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

// CRepeatInfo::WeekStart

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

//

EXPORT_C TDay CRepeatInfo::WeekStart()

	{

	return iWkSt;

	}

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

// CRepeatInfo::Month

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

//	

EXPORT_C TMonth CRepeatInfo::Month()

	{

	return iMonth;	

	}

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

// CRepeatInfo::DaysInWeek

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

//	

EXPORT_C RArray<TDay>& CRepeatInfo::DaysInWeek()

	{

	return iWeekDays;	

	}

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

// CRepeatInfo::DaysInMonth

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

//

EXPORT_C RArray<TCalRRule::TDayOfMonth>& CRepeatInfo::DaysInMonth()

	{

	return iMonthDays;	

	}

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

// CRepeatInfo::DatesInMonth

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

//

EXPORT_C RArray<TInt>& CRepeatInfo::DatesInMonth()

	{

	return iMonthDates;	

	}

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

// CRepeatInfo::Interval

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

//

EXPORT_C TInt CRepeatInfo::Interval()

	{

	return iInterval;	

	}

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

// CRepeatInfo::UntilDate

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

//

EXPORT_C TCalTime& CRepeatInfo::UntilDate()

	{

	return iUntilTime;	

	}

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

// CRepeatInfo::Type

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

//

EXPORT_C TCalRRule::TType CRepeatInfo::Type()

	{

	return iType;	

	}

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

// CRepeatInfo::GetRepeatRule

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

//

EXPORT_C TCalRRule& CRepeatInfo::GetRepeatRule()	

	{

	return iRule;	

	}

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

// CEntryAttributes::NewL

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

//	

EXPORT_C CEntryAttributes* CEntryAttributes::NewL( const TDesC& aType )

	{

	CEntryAttributes* self = new (ELeave) CEntryAttributes;

	CleanupStack::PushL( self );

	self->ConstructL( aType );

	CleanupStack::Pop( self );

	return self;

	}

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

// CEntryAttributes::NewL

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

//	

EXPORT_C CEntryAttributes* CEntryAttributes::NewL()

	{

	return new (ELeave) CEntryAttributes;

	}

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

// Destructor

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

//	

CEntryAttributes::~CEntryAttributes()

	{

	delete iSummary;

	delete iDescription;

	delete iLocation;

	delete iPhoneOwner;

    delete iOrganizer;

    iRepeatDates.Close();

	iExDates.Close();

	iAttendees.ResetAndDestroy();

	}

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

// CEntryAttributes::ConstructL

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

//

void CEntryAttributes::ConstructL( const TDesC& aType )

	{

	SetTypeL( aType );

	iStartTime.SetTimeUtcL( Time::NullTTime() );

	iEndTime.SetTimeUtcL( Time::NullTTime() );

	}

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

// CEntryAttributes::SetTypeL

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

//

EXPORT_C void CEntryAttributes::SetTypeL( const TDesC& aType )

	{

	if ( aType.CompareF(KEntryAppt) == 0 )

		iType = CCalEntry::EAppt; // apointment entry

	else if ( aType.CompareF(KEntryTodo) == 0 )

		iType = CCalEntry::ETodo; // todo entry

	else if ( aType.CompareF(KEntryEvent) == 0 )

		iType = CCalEntry::EEvent; // event entry

	else if ( aType.CompareF(KEntryReminder) == 0 )

		iType = CCalEntry::EReminder; // reminder entry

	else if ( aType.CompareF(KEntryAnniv) == 0 )

		iType = CCalEntry::EAnniv; // anniversary entry

	else

		User::Leave(KErrArgument);

	iSetAttributes |= EEntryType;

	}

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

// CEntryAttributes::SetStartTimeL

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

//	

EXPORT_C void CEntryAttributes::SetStartTimeL( const TTime& aStartTime )

	{

	if ( aStartTime != Time::NullTTime())

		{

		if( aStartTime < TCalTime::MinTime() || aStartTime > TCalTime::MaxTime() )

			User::Leave( KErrArgument );

		iSetAttributes |= EStartTime;

		iStartTime.SetTimeUtcL( aStartTime );

		}

	}

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

// CEntryAttributes::SetEndTimeL

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

//	

EXPORT_C void CEntryAttributes::SetEndTimeL( const TTime& aEndTime )

	{

	if ( aEndTime != Time::NullTTime() )

		{

		if( aEndTime < TCalTime::MinTime() || aEndTime > TCalTime::MaxTime() )

			User::Leave( KErrArgument );

		iEndTime.SetTimeUtcL( aEndTime );