/*
* Copyright (c) 2008 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:  Concrete Class for Location Events.
*
*/


// System Includes

// User Includes
#include "evtevent.h"
#include "evtaction.h"

// ================ Member funtions for CEvtEvent class ======================

// ---------------------------------------------------------------------------
// CEvtEvent::CEvtEvent
// ---------------------------------------------------------------------------
//
CEvtEvent::CEvtEvent():
	iEventId( 0 ),
	iEventStatus( EDraft ),
	iRadius( 0.1 ),
	iRepeat( EFalse )
    {    
    }
    
// ---------------------------------------------------------------------------
// CEvtEvent::~CEvtEvent
// ---------------------------------------------------------------------------
//
CEvtEvent::~CEvtEvent()
    {
    delete iSubject;
    delete iPlace;
    delete iDescription;
    if( iAction )
    	delete iAction;
    delete iLocation;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtEvent* CEvtEvent::NewL()
    {
	CEvtEvent* self = NewLC( );
	CleanupStack::Pop( self );
	return self;
    }

// ---------------------------------------------------------------------------
// CEvtEvent::NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtEvent* CEvtEvent::NewLC()
    {
	CEvtEvent* self = new ( ELeave )CEvtEvent( );
	CleanupStack::PushL( self );
	self->ConstructL( );
	return self;
    } 

// ---------------------------------------------------------------------------
// CEvtEvent::ConstructL
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::ConstructL()
    {
    // Allocate the Null string by default
    iSubject = KNullDesC().AllocL();
    iPlace = KNullDesC().AllocL();
    iDescription = KNullDesC().AllocL();
    iLocation = new TPosition();
    }
    
// ---------------------------------------------------------------------------
// CEvtEvent::EventId
// ---------------------------------------------------------------------------
//
EXPORT_C TEvtEventId CEvtEvent::EventId() const
    {
    return iEventId;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetEventId
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetEventId( const TEvtEventId aId )
    {
    iEventId = aId;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Subject
// ---------------------------------------------------------------------------
//
EXPORT_C TPtrC CEvtEvent::Subject() const
    {
    return iSubject->Des();
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetSubjectL
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetSubjectL( const TDesC& aSubject )
    {
    delete iSubject;
    iSubject = NULL;
    iSubject = aSubject.AllocL();
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Place
// ---------------------------------------------------------------------------
//
EXPORT_C TPtrC CEvtEvent::Place() const
    {
    return *iPlace;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetPlaceL
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetPlaceL( const TDesC& aPlace )
    {
    delete iPlace;
    iPlace = NULL;
    iPlace = aPlace.AllocL();
    } 
  
// ---------------------------------------------------------------------------
// CEvtEvent::EventStatus
// ---------------------------------------------------------------------------
//
EXPORT_C TEvtEventStatus CEvtEvent::EventStatus() const
    {
    return iEventStatus;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetEventStatus
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetEventStatus( 
                            const TEvtEventStatus aEventStatus )
    {
    iEventStatus = aEventStatus;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Radius
// ---------------------------------------------------------------------------
//
EXPORT_C TReal CEvtEvent::Radius() const
    {
    return iRadius;
    }
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetRadius
// radius will always be in km.
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetRadius( const TReal aRadius )
    {
    iRadius = aRadius;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Repeat
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CEvtEvent::Repeat() const
    {
    return iRepeat;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetRepeat
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetRepeat( const TBool aRepeat )
    {
    iRepeat = aRepeat;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Description
// ---------------------------------------------------------------------------
//
EXPORT_C TPtrC CEvtEvent::Description() const
    {
    return iDescription->Des();
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetDescriptionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetDescriptionL( const TDesC& aDescription )
    {
    delete iDescription;
    iDescription = NULL;
    iDescription = aDescription.AllocL();
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::Action
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtAction& CEvtEvent::Action() const
    {
    return *iAction;
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::SetActionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtEvent::SetActionL( CEvtAction* aAction )
    {
	// Clear Action , if the aAction is NULL
    if( !aAction  ) 
        {
        if( iAction )
            {
            delete iAction;
            iAction = NULL;
            }
        return;
        }
		
	// Set the Action Id and String if aAction is present.	
    TInt64 id = aAction->Id();
    if(iAction)
        {
        id = iAction->Id();
        delete iAction;
    	iAction = NULL;
        }
    iAction = aAction;
    iAction->SetId( id );
    iAction->SetEvtId(EventId());
    } 
    
// ---------------------------------------------------------------------------
// CEvtEvent::HasAction
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CEvtEvent::HasAction( )
	{
	return (iAction)?ETrue:EFalse;
	}

// ---------------------------------------------------------------------------
// CEvtEvent::Location
// ---------------------------------------------------------------------------
//
EXPORT_C TPosition& CEvtEvent::Location() const
    {
    return *iLocation;
    }

// ---------------------------------------------------------------------------
// CEvtEvent::HasAction
// ---------------------------------------------------------------------------
//
void CEvtEvent::SetLocationL(TPosition& aLocation)
    {
    *iLocation = aLocation;
    }
// End of File