/*

* Copyright (c) 2007-2009 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:  ESMR UI Factory implementation

*

*/

#include "emailtrace.h"

#include "cesmrfieldstorage.h"

#include "cesmrfield.h"

#include "mesmrcalentry.h"

#include "cesmrfieldeventqueue.h"

// <cmail> Removed profiling. </cmail>

// ======== MEMBER FUNCTIONS ========

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

// CESMRFieldStorage::CESMRFieldStorage()

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

//

CESMRFieldStorage::CESMRFieldStorage(

		MESMRFieldEventObserver& aEventObserver ): 

	iEventObserver( aEventObserver )

    {

    FUNC_LOG;

    // Do nothing

    }

void CESMRFieldStorage::BaseConstructL()

    {

    FUNC_LOG;

    // Add event observer to event queue

    EventQueueL().AddObserverL( &iEventObserver );

    }

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

// CESMRFieldStorage::~CESMRFieldStorage()

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

//

CESMRFieldStorage::~CESMRFieldStorage()

    {

    FUNC_LOG;

    iArray.ResetAndDestroy();

    delete iPlugin;

    delete iEventQueue;

    }

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

// CESMRFieldStorage::AddFieldL()

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

//

void CESMRFieldStorage::AddFieldL( CESMRField* aField )

    {

    FUNC_LOG;

    if ( aField )

        {

        AddFieldL( aField, ETrue );

        }

    }

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

// CESMRFieldStorage::AddFieldL()

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

//

void CESMRFieldStorage::AddFieldL( CESMRField* aField, TBool aVisible )

    {

    FUNC_LOG;

    if ( aField )

        {

        iArray.ReserveL( iArray.Count() + 1 );

        aField->SetEventQueueL( iEventQueue );

        aField->MakeVisible( aVisible );

        iArray.AppendL( aField );

        }

    }

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

// CESMRFieldStorage::Count()

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

//

TInt CESMRFieldStorage::Count() const

    {

    FUNC_LOG;

    return iArray.Count();

    }

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

// CESMRFieldStorage::Field()

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

//

CESMRField* CESMRFieldStorage::Field( TInt aInd ) const

    {

    FUNC_LOG;

    return iArray[ aInd ];

    }

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

// CESMRFieldStorage::FieldById

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

//

CESMRField* CESMRFieldStorage::FieldById( TESMREntryFieldId aId ) const

    {

    CESMRField* field = NULL;

    for ( TInt i = 0; i < iArray.Count(); ++i )

        {

        if ( iArray[ i ]->FieldId() == aId )

            {

            field = iArray[ i ];

            break;

            }

        }

    return field;

    }

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

// CESMRFieldStorage::Validate()

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

//

TInt CESMRFieldStorage::Validate( 

		TESMREntryFieldId& /*aId */, 

		TBool /*aForceValidation*/ )

    {

    FUNC_LOG;

    return KErrNone;

    }

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

// CESMRFieldStorage::InternalizeL()

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

//

void CESMRFieldStorage::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    for ( TInt i(0); i < iArray.Count(); i++ )

        {

        iArray[ i ]->InternalizeL( aEntry );

        }

    }

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

// CESMRFieldStorage::ExternalizeL()

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

//

void CESMRFieldStorage::ExternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    for ( TInt i(0); i < iArray.Count(); i++ )

        {

        iArray[ i ]->ExternalizeL( aEntry );

        }

    }

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

// CESMRFieldStorage::FieldBuilderL()

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

//

MESMRFieldBuilder* CESMRFieldStorage::FieldBuilderL()

    {

    FUNC_LOG;

    if(!iFieldBuilder)

        {

        LoadPluginL();

        }

    return iFieldBuilder;

    }

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

// CESMRFieldStorage::LoadPluginL()

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

//

void CESMRFieldStorage::LoadPluginL()

    {

    FUNC_LOG;

    iFieldBuilder = NULL;

    CESMRFieldBuilderInterface* plugin = NULL;

	TRAPD( error, plugin = 

		CESMRFieldBuilderInterface::CreatePluginL( 

				TUid::Uid(KESMRUIFieldBuilderPluginImplUId) ) );

	if ( error == KErrNone && plugin)

		{   

		delete iPlugin;

		iPlugin = plugin;

		iFieldBuilder = iPlugin->FieldBuilderL();

		}

    }

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

// CESMRFieldStorage::CreateEditorFieldL()

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

//

CESMRField* CESMRFieldStorage::CreateEditorFieldL( 

		MESMRFieldValidator* aValidator, 

		TESMREntryField aField )

    {

    FUNC_LOG;

    CESMRField* field = NULL;

    if (FieldBuilderL())

        {

        field = FieldBuilderL()->CreateEditorFieldL(aValidator, aField);

        }

    return field;

    }

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

// CESMRFieldStorage::CreateViewerFieldL()

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

//

CESMRField* CESMRFieldStorage::CreateViewerFieldL( 

		MESMRResponseObserver* aResponseObserver, 

		TESMREntryField aField, 

		TBool aResponseReady )

    {

    FUNC_LOG;

    CESMRField* field = NULL;

    if (FieldBuilderL())

        {

        field = FieldBuilderL()->CreateViewerFieldL(

					aResponseObserver, aField, aResponseReady );

        }

    return field;

    }

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

// CESMRFieldStorage::EventQueueL()

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

//

CESMRFieldEventQueue& CESMRFieldStorage::EventQueueL()

    {

    FUNC_LOG;

    if ( !iEventQueue )

        {

        iEventQueue = CESMRFieldEventQueue::NewL();

        }

    return *iEventQueue;

    }

// EOF