/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:   Meeting request support implementation.

*

*/

#include "basemrinfoobject.h"

#include "baseplugin.h"

/**

 * Defaults: Method of EMRMethodRequest.

 */

EXPORT_C CBaseMrInfoObject* CBaseMrInfoObject::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

/**

 * Copy construction.

 */

EXPORT_C CBaseMrInfoObject* CBaseMrInfoObject::NewL(

    MMRInfoObject& aMrInfo )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aMrInfo );

    CleanupStack::Pop( self );

    return self;

    }

/**

 *

 */

CBaseMrInfoObject::CBaseMrInfoObject()

    : iCreationTime( Time::NullTTime() ), iStartTime( Time::NullTTime() ),

    iEndTime( Time::NullTTime() ), iAlarmTime( Time::NullTTime() ),

    iRecurrenceId( Time::NullTTime() ), iPriority( KIcalNormalPriority ), iMethod( EMRMethodRequest ),

    iResponse( EMrCmdResponseTentative )

    {

    }

/**

 * Copy construction

 */

void CBaseMrInfoObject::ConstructL(

    MMRInfoObject& aMrInfo )

    {    

    iSubject = aMrInfo.SubjectL().AllocL();

    iDescription = aMrInfo.DescriptionL().AllocL();

    iLocation = aMrInfo.LocationL().AllocL();

    iUid = aMrInfo.UidL().AllocL();

    iCreationTime = aMrInfo.CreationTimeInUtcL();

    iStartTime = aMrInfo.StartTimeInUtcL();

    iEndTime = aMrInfo.EndTimeInUtcL();

    iAlarmTime = aMrInfo.AlarmInUtcL();

    iMethod = aMrInfo.MRMethodL();

    iResponse = aMrInfo.MRResponse();

    iRecurrenceId = aMrInfo.MRRecurrenceId();

    iSequenceNumber = aMrInfo.MRSequenceNumberL();

    iPriority = aMrInfo.PriorityL();

    iOrganizer = CBaseMrAttendee::NewL( aMrInfo.MROrganizerL() );

    RPointerArray<MMRAttendee>& attendees = aMrInfo.AttendeesL();

    TInt count = attendees.Count();

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

        {

        MMRAttendee* attendee = CBaseMrAttendee::NewL( *(attendees[i]) );

        CleanupStack::PushL( attendee );

        iAttendees.AppendL( attendee );

        CleanupStack::Pop( attendee );

        }

    iRrule = CBaseMrRecurrenceRule::NewL( aMrInfo.RecurrenceRuleL() );

    /**@ copy construction for iExceptions, iAttachments.*/

    }

/**

 *

 */

void CBaseMrInfoObject::ConstructL()

    {    

    iSubject = KNullDesC().AllocL();

    iDescription = KNullDesC().AllocL();

    iLocation = KNullDesC().AllocL();

    iUid = KNullDesC().AllocL();

    iOrganizer = CBaseMrAttendee::NewL();

    }

/**

 *

 */

EXPORT_C CBaseMrInfoObject::~CBaseMrInfoObject()

    {

    delete iSubject;

    delete iDescription;

    delete iLocation;

    delete iUid;

    delete iOrganizer;

    iExceptions.ResetAndDestroy();

    iAttachments.ResetAndDestroy();

    iAttendees.ResetAndDestroy();

    delete iRrule;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetMRRecurrenceIdL( TTime aRecId )

    {

    iRecurrenceId = aRecId;

    }

/**

 *

 */

EXPORT_C TTime CBaseMrInfoObject::MRRecurrenceId() const

    {

    return iRecurrenceId;

    }

/**

 * 

 */

EXPORT_C void CBaseMrInfoObject::SetMRSequenceNumber( TInt aSeqNo )

	{

	iSequenceNumber = aSeqNo;

	}

/**

 *

 */

EXPORT_C TInt CBaseMrInfoObject::SupportedFields(

    RArray<TESMRInfoField>& aFields ) const

    {

    /**@ have more fields to add.*/

    TESMRInfoField fields[] = 

        {

        EESMRInfoFieldId,

        EESMRInfoFieldSeqNo,

        EESMRInfoFieldMethod,

        EESMRInfoFieldMStatus,

        EESMRInfoFieldCreationDateTime,

        EESMRInfoFieldOrganizer,

        EESMRInfoFieldAttendee,

        EESMRInfoFieldOptAttendee,

        EESMRInfoFieldStartDateTime,

        EESMRInfoFieldStopDateTime,

        EESMRInfoFieldLocation,

        EESMRInfoFieldAlarm,

        EESMRInfoFieldSubject,

        EESMRInfoFieldDescription,

        EESMRInfoFieldRecurrence,

        EESMRInfoFieldPriority

        };

    TInt result = KErrNone;

    for ( TInt i = 0;

        i < sizeof( fields ) / sizeof( TESMRInfoField ) && result == KErrNone;

        i++ )

        {

        result = aFields.Append( fields[i] );

        }

    return result;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetUidL(

    const TDesC& aUid )

    {

    delete iUid;

    iUid = NULL;

    iUid = aUid.AllocL();

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetUidL(

    HBufC* aUid )

    {

    delete iUid;

    iUid = NULL;

    iUid = aUid;

    }

/**

 *

 */

EXPORT_C const TDesC& CBaseMrInfoObject::UidL() const

    {

    return *iUid;

    }

/**

 *

 */

EXPORT_C TInt CBaseMrInfoObject::MRSequenceNumberL() const

    {

    return iSequenceNumber;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetMethod(

    TMRMethod aMethod )

    {

    iMethod = aMethod;

    }

/**

 *

 */

EXPORT_C MMRInfoObject::TMRMethod CBaseMrInfoObject::MRMethodL() const

    {

    return iMethod;

    }

/**

 *

 */

EXPORT_C MMROrganizer& CBaseMrInfoObject::MROrganizerL()

    {

    return *iOrganizer;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::AddAttendeeL(

    MMRAttendee* aAttendee )

    {

    iAttendees.AppendL( aAttendee );

    }

/**

 *

 */

EXPORT_C RPointerArray<MMRAttendee>& CBaseMrInfoObject::AttendeesL()

    {

    return iAttendees;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetCreationTimeInUtcL(

    TTime aTime )

    {

    iCreationTime = aTime;

    }

/**

 *

 */

EXPORT_C TTime CBaseMrInfoObject::CreationTimeInUtcL() const

    {

    return iCreationTime;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetStartTimeInUtcL(

    TTime aTime )

    {

    iStartTime = aTime;

    }

/**

 *

 */

EXPORT_C TTime CBaseMrInfoObject::StartTimeInUtcL() const

    {

    return iStartTime;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetEndTimeInUtcL(

    TTime aTime )

    {

    iEndTime = aTime;

    }

/**

 *

 */

EXPORT_C TTime CBaseMrInfoObject::EndTimeInUtcL() const

    {

    return iEndTime;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetAlarmInUtcL(

    TTime aTime )

    {

    iAlarmTime = aTime;

    }

/**

 *

 */

EXPORT_C TTime CBaseMrInfoObject::AlarmInUtcL() const

    {

    return iAlarmTime;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetLocationL(

    const TDesC& aLocation )

    {

    delete iLocation;

    iLocation = NULL;

    iLocation = aLocation.AllocL();

    }

/**

 *

 */

EXPORT_C const TDesC& CBaseMrInfoObject::LocationL() const

    {

    return *iLocation;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetDescriptionL(

    const TDesC& aDescription )

    {

    delete iDescription;

    iDescription = NULL;

    iDescription = aDescription.AllocL();

    }

/**

 *

 */

EXPORT_C const TDesC& CBaseMrInfoObject::DescriptionL() const

    {

    return *iDescription;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetSubjectL(

    const TDesC& aSubject )

    {

    delete iSubject;

    iSubject = NULL;

    iSubject = aSubject.AllocL();

    }

/**

 *

 */

EXPORT_C const TDesC& CBaseMrInfoObject::SubjectL() const

    {

    return *iSubject;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetRecurrenceRuleL(

    const MRRecurrenceRule& aRRule )

    {

    iRrule = &aRRule;

    }

/**

 *

 */

EXPORT_C const MRRecurrenceRule& CBaseMrInfoObject::RecurrenceRuleL() const

    {

    return *iRrule;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::AddRecurrenceExceptionL(

    MMRInfoObject* aException )

    {

    iExceptions.AppendL( aException );

    }

/**

 *

 */

EXPORT_C const RPointerArray<MMRInfoObject>&

    CBaseMrInfoObject::RecurrenceExceptionsL() const

    {

    return iExceptions;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetPriorityL(

    TUint aPriority )

    {

    iPriority = aPriority;

    }

/**

 *

 */

EXPORT_C TUint CBaseMrInfoObject::PriorityL() const

    {

    return iPriority;

    }

/**

 *

 */

EXPORT_C const RPointerArray<MMRAttachment>& CBaseMrInfoObject::AttachmentsL() const

    {

    return iAttachments;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::AddAttachmentsL(

    MMRAttachment* aAttachment )

    {

    iAttachments.AppendL( aAttachment );

    }

/**

 *

 */

EXPORT_C TAny* CBaseMrInfoObject::ExtensionL(

    TUid /*aExtensionUid*/ )

    {

    return NULL;

    }

/**

 *

 */

EXPORT_C void CBaseMrInfoObject::SetMRResponseL(

    TResponse aResponse )

    {