/*

* 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 priority field implementation

 *

*/

#include "cesmrpriorityfield.h"

#include "cesmrlistquery.h"

#include "mesmrtitlepaneobserver.h"

#include <calentry.h>

#include <esmrgui.rsg>

#include <barsread.h>

#include <eiklabel.h>

#include <avkon.hrh>

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

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

// CESMRPriorityField::NewL

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

//

    {

    FUNC_LOG;

    CESMRPriorityField* self = new (ELeave) CESMRPriorityField;

    CleanupStack::PushL ( self );

    self->ConstructL ( );

    CleanupStack::Pop ( self );

    return self;

    }

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

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

//

    {

    }

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

// CESMRPriorityField::InitializeL

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

//

void CESMRPriorityField::InitializeL()

    {

    FUNC_LOG;

    }

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

// CESMRPriorityField::InternalizeL

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

//

void CESMRPriorityField::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    TInt prior = aEntry.GetPriorityL ( );

    iEntryType = aEntry.Type();

    // esmrgui.rss

    TResourceReader reader;

    TInt resourceId(KErrNotFound);

    if ( aEntry.Type() == MESMRCalEntry::EESMRCalEntryTodo )

        {

        resourceId = R_ESMREDITOR_TODO_PRIORITY;

        }

    else

        {

        resourceId = R_ESMREDITOR_PRIORITY;

        }

    iCoeEnv->CreateResourceReaderLC ( reader, resourceId );

    iArray.Reset ( );

    // Read priority items to array

    TInt count = reader.ReadInt16 ( );

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

        {

        CESMRPriority* priority = new (ELeave) CESMRPriority;

        CleanupStack::PushL ( priority );

        priority->ConstructFromResourceL ( reader );

        iArray.AppendL ( priority );

        CleanupStack::Pop ( priority );

        if ( priority->Id ( )== prior )

            {

            iIndex = i;

            UpdateTextL ( iIndex );

            }

        }

    // reader

    CleanupStack::PopAndDestroy(); // codescanner::cleanup 

    }

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

// CESMRPriorityField::ExternalizeL

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

//

void CESMRPriorityField::ExternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    if ( iIndex < iArray.Count() )

        {

        CCalEntry& calEntry = aEntry.Entry ( );

        calEntry.SetPriorityL ( iArray[iIndex]->Id ( ) );

        }

    else

        {

        User::Leave( KErrOverflow );

        }

    }

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

// CESMRPriorityField::SetOutlineFocusL

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

//

void CESMRPriorityField::SetOutlineFocusL( TBool aFocus )

    {

    FUNC_LOG;

    //Focus gained

    if ( aFocus )

        {

        ChangeMiddleSoftKeyL(EESMRCmdOpenPriorityQuery, R_QTN_MSK_OPEN);

        }

    }

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

// CESMRPriorityField::ExecuteGenericCommandL()

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

//

    {

    FUNC_LOG;

    if( aCommand == EESMRCmdOpenPriorityQuery ||

        aCommand == EAknCmdOpen )

        {

        ExecutePriorityQueryL();

        }

    }

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

// CESMRPriorityField::ExecutePriorityQueryL

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

//

void CESMRPriorityField::ExecutePriorityQueryL()

    {

    FUNC_LOG;

    TInt ret(KErrNone);

    if ( iEntryType == MESMRCalEntry::EESMRCalEntryTodo)

        {

        ret = CESMRListQuery::ExecuteL (CESMRListQuery::EESMRTodoPriorityPopup );

        }

    else

        {

        ret = CESMRListQuery::ExecuteL (CESMRListQuery::EESMRPriorityPopup );

        }

    if ( ret != KErrCancel )

        {

        // ret is priority value, not index

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

            {

            if ( iArray[i]->Id() == ret )

                {

                iIndex = i;

                UpdateTextL( iIndex );

                break;

                }

            }

        }

    }

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

// CESMRPriorityField::OfferKeyEventL

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

//

TKeyResponse CESMRPriorityField::OfferKeyEventL(const TKeyEvent& aEvent,

        TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed);

    if ( aType == EEventKey )

        {

        switch ( aEvent.iScanCode )

            {

            case EStdKeyLeftArrow:

                {

                if ( iIndex > 0 )

                    {

                    UpdateTextL ( --iIndex );

                    response = EKeyWasConsumed;

                    }

                }

                break;

            case EStdKeyRightArrow:

                {

                if ( iIndex < iArray.Count ( )- 1 )

                    {

                    UpdateTextL ( ++iIndex );

                    response = EKeyWasConsumed;

                    }

                }

                break;

            case EStdKeyDevice3:

                {

                TInt ret(KErrNone);

                if ( iEntryType == MESMRCalEntry::EESMRCalEntryTodo)

                    {

                    ret = CESMRListQuery::ExecuteL (CESMRListQuery::EESMRTodoPriorityPopup );

                    }

                else

                    {

                    ret = CESMRListQuery::ExecuteL (CESMRListQuery::EESMRPriorityPopup );

                    }

                if ( ret != KErrCancel )

                    {

                    // ret is priority value, not index

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

                        {

                        if ( iArray[i]->Id() == ret )

                            {

                            iIndex = i;

                            UpdateTextL( iIndex );

                            break;

                            }

                        }

                    }

                response = EKeyWasConsumed;

                }

                break;

            default:

                break;

            }

        }

    return response;

    }

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

// CESMRPriorityField::UpdateTextL

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

//

void CESMRPriorityField::UpdateTextL( TInt aIndex )

    {

    FUNC_LOG;

    CESMRPriority* priority = iArray[ aIndex ];

    switch ( priority->Id() )

        {

        case EFSCalenMRPriorityLow:

        case EFSCalenTodoPriorityLow:

            {

            break;

            }

        case EFSCalenMRPriorityUnknown:

        case EFSCalenMRPriorityNormal:

        case EFSCalenTodoPriorityNormal:

            {

            break;

            }

        case EFSCalenMRPriorityHigh: // same value as EFSCalenTodoPriorityHigh

            {

            break;

            }

        default:

        	ASSERT(EFalse);

        	break;

        }

    }

// EOF