/*
* 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 Synchronization field implementation
 *
*/

#include "emailtrace.h"
#include "cesmrsyncfield.h"

#include <eiklabel.h>
#include <esmrgui.rsg>
#include <StringLoader.h>
#include <barsread.h>
#include <avkon.hrh>
#include <AknsConstants.h>
#include <AknUtils.h>

#include "cesmrsync.h"
#include "cesmrlistquery.h"
#include <calentry.h>

// Unnamed namespace for local definitions and functions
namespace{ // codescanner::namespace

CCalEntry::TReplicationStatus MapToReplicationStatus(
        TESMRSyncValue aSyncValue )
    {
    CCalEntry::TReplicationStatus ret;
    switch ( aSyncValue )
        {
        case ESyncNone:
            {
            ret = CCalEntry::ERestricted;
            break;
            }
        case ESyncPrivate:
            {
            ret = CCalEntry::EPrivate;
            break;
            }
        case ESyncPublic:
            {
            ret = CCalEntry::EOpen;
            break;
            }
        default:
            {
            ret = CCalEntry::ERestricted;
            }
        }

    return ret;
    }

} // namespace

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

// ---------------------------------------------------------------------------
// CESMRSyncField::NewL
// ---------------------------------------------------------------------------
//
CESMRSyncField* CESMRSyncField::NewL( )
    {
    FUNC_LOG;
    CESMRSyncField* self = new (ELeave) CESMRSyncField;
    CleanupStack::PushL ( self );
    self->ConstructL ( );
    CleanupStack::Pop ( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::~CESMRSyncField
// ---------------------------------------------------------------------------
//
CESMRSyncField::~CESMRSyncField( )
    {
    FUNC_LOG;
    iArray.ResetAndDestroy ( );
    iArray.Close ( );
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::InitializeL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::InitializeL()
    {
    FUNC_LOG;
    iSync->SetFont( iLayout->Font( iCoeEnv, iFieldId ) );
    iSync->SetLabelAlignment( CESMRLayoutManager::IsMirrored()
                              ? ELayoutAlignRight : ELayoutAlignLeft );
    AknLayoutUtils::OverrideControlColorL(*iSync,
                                           EColorLabelText,
                                           iLayout->GeneralListAreaTextColor() );
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::InternalizeL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::InternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    TInt synchValue = aEntry.Entry().ReplicationStatusL ( );

    // esmrgui.rss
    TResourceReader reader;
    iCoeEnv->CreateResourceReaderLC ( reader, R_ESMREDITOR_SYNC );

    // Read sync items to array
    iArray.ResetAndDestroy( );
    TInt count = reader.ReadInt16 ( );
    for (TInt i(0); i < count; i++ )
        {
        CESMRSync* sync = new (ELeave) CESMRSync();
        CleanupStack::PushL( sync );
        sync->ConstructFromResourceL ( reader );
        iArray.AppendL ( sync );
        CleanupStack::Pop( sync );
        if ( synchValue == MapToReplicationStatus ( sync->Id ( ) ) )
            {
            iIndex = i;
            iSync->SetTextL ( sync->TextL ( ) );
            }
        }
    // resource reader
    CleanupStack::PopAndDestroy(); // codescanner::cleanup
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::ExternalizeL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::ExternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    if ( iIndex < iArray.Count() )
        {
        CCalEntry::TReplicationStatus
            repStatus = MapToReplicationStatus ( iArray[iIndex]->Id ( ) );
        aEntry.Entry().SetReplicationStatusL (repStatus );
        }
    else
        {
        User::Leave( KErrOverflow );
        }
    }

// ---------------------------------------------------------------------------
// CESMRPriorityField::SetOutlineFocusL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::SetOutlineFocusL( TBool aFocus )
    {
    FUNC_LOG;
    CESMRField::SetOutlineFocusL ( aFocus );

    //Focus gained
    if ( aFocus )
        {
        ChangeMiddleSoftKeyL(EESMRCmdOpenSyncQuery, R_QTN_MSK_OPEN);
        }
    }

// ---------------------------------------------------------------------------
// CESMRPriorityField::ExecuteGenericCommandL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::ExecuteGenericCommandL( TInt aCommand )
    {
    FUNC_LOG;
    if(aCommand == EESMRCmdOpenSyncQuery ||
       aCommand == EAknCmdOpen )
        {
        ExecuteSyncQueryL();
        }
    }

// ---------------------------------------------------------------------------
// CESMRPriorityField::ExecuteSyncQuery
// ---------------------------------------------------------------------------
//
void CESMRSyncField::ExecuteSyncQueryL()
    {
    FUNC_LOG;

    TInt ret =
        CESMRListQuery::ExecuteL( CESMRListQuery::EESMRSynchronizationPopup );
    if ( ret != KErrCancel )
        {
        iIndex = ret;
        UpdateLabelL (ret );
        }
    }


// ---------------------------------------------------------------------------
// CESMRSyncField::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CESMRSyncField::OfferKeyEventL( const TKeyEvent& aEvent,
        TEventCode aType )
    {
    FUNC_LOG;
    TKeyResponse response( EKeyWasNotConsumed);
    if ( aType == EEventKey )
        {
        switch ( aEvent.iScanCode )
            {
            case EStdKeyLeftArrow:
                {
                if ( iIndex > 0 )
                    {
                    UpdateLabelL ( --iIndex );
                    response = EKeyWasConsumed;
                    }
                }
                break;

            case EStdKeyRightArrow:
                {
                if ( iIndex < (iArray.Count() - 1) )
                    {
                    UpdateLabelL ( ++iIndex );
                    response = EKeyWasConsumed;
                    }
                }
                break;

            default:
                break;
            }
        }
    return response;
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::CESMRSyncField
// ---------------------------------------------------------------------------
//
CESMRSyncField::CESMRSyncField( ) :
    iIndex(0)
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::ConstructL( )
    {
    FUNC_LOG;
    SetFieldId( EESMRFieldSync );

    iSync = new (ELeave) CEikLabel;
    iSync->SetTextL( KNullDesC );

    TGulAlignment align;
    align.SetHAlignment( EHLeft );
    align.SetVAlignment( EVCenter );
    iSync->SetAlignment( align );

    CESMRIconField::ConstructL(
            KAknsIIDQgnFscalIndiSynchronisation,
            iSync );
    }

// ---------------------------------------------------------------------------
// CESMRSyncField::UpdateLabelL
// ---------------------------------------------------------------------------
//
void CESMRSyncField::UpdateLabelL( TInt aIndex )
    {
    FUNC_LOG;
    CESMRSync* sync = iArray[ aIndex ];
    iSync->SetTextL( sync->TextL() );
    iSync->DrawDeferred();
    }

// EOF