/*
* Copyright (c) 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 "cesmrfieldstorage.h"
#include "cesmrfield.h"
#include "mesmrcalentry.h"
#include "cesmrfieldeventqueue.h"
#include "cmrsystemnotifier.h"

#include <touchfeedback.h>

#include "emailtrace.h"


// ======== 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 );    
    iSystemNotifier = CMRSystemNotifier::NewL( EventQueueL() );
    iSystemNotifier->StartL();
    }

// ---------------------------------------------------------------------------
// CESMRFieldStorage::~CESMRFieldStorage()
// ---------------------------------------------------------------------------
//
CESMRFieldStorage::~CESMRFieldStorage()
    {
    FUNC_LOG;
    iArray.ResetAndDestroy();

    delete iPlugin;
    delete iSystemNotifier;
    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;

    TInt index(0);
    while( index < iArray.Count() )
        {
        TInt fieldCount( iArray.Count() );
        iArray[ index ]->InternalizeL( aEntry );

        if ( fieldCount == iArray.Count() )
            {
            // Field that was internalized was not removed from list
            // We can update field index. If field is removed the next
            // field index is already the current index ...
            index++;
            }
        }
    }

// ---------------------------------------------------------------------------
// CESMRFieldStorage::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CESMRFieldStorage::ExternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    for ( TInt i(0); i < iArray.Count(); i++ )
        {
        if(iArray[ i ]->IsVisible())
        	{
        	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::ChangePolicyL()
// -----------------------------------------------------------------------------
//
void CESMRFieldStorage::ChangePolicyL(
        const CESMRPolicy& /*aNewPolicy*/,
        MESMRCalEntry& /*aEntry*/ )
    {
    ASSERT( EFalse ); // Assert for debug builds
    User::Leave( KErrNotSupported );
    }

// -----------------------------------------------------------------------------
// CESMRFieldStorage::EventQueueL()
// -----------------------------------------------------------------------------
//
CESMRFieldEventQueue& CESMRFieldStorage::EventQueueL()
    {
    FUNC_LOG;
    if ( !iEventQueue )
        {
        iEventQueue = CESMRFieldEventQueue::NewL();
        }
    return *iEventQueue;
    }

// -----------------------------------------------------------------------------
// CESMRFieldStorage::RemoveField()
// -----------------------------------------------------------------------------
//
void CESMRFieldStorage::RemoveField( TInt aInd )
    {
    CESMRField* field = iArray[ aInd ];
    iArray.Remove( aInd );
    delete field;
    }

// -----------------------------------------------------------------------------
// CESMRFieldStorage::InsertFieldL()
// -----------------------------------------------------------------------------
//
void CESMRFieldStorage::InsertFieldL( CESMRField* aField, TInt aIndex )
    {
    iArray.InsertL( aField, aIndex );
    aField->SetEventQueueL( iEventQueue );
    }

// -----------------------------------------------------------------------------
// CESMRFieldStorage::ReserveL()
// -----------------------------------------------------------------------------
//
void CESMRFieldStorage::ReserveL( TInt aCount )
    {
    iArray.ReserveL( aCount );
    }

// -----------------------------------------------------------------------------
// CESMRFieldStorage::Reset()
// -----------------------------------------------------------------------------
//
void CESMRFieldStorage::Reset()
    {
    iArray.ResetAndDestroy();
    }
// EOF