/*

* 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:  Implementation of the class CFscContactActionMenuImpl.

*

*/

// INCUDES

#include "emailtrace.h"

#include <ecom/implementationproxy.h>

#include "cfsccontactactionservice.h"

#include <eikbtgpc.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <AknsUtils.h>

#include <aknnotewrappers.h> 

#include <textresolver.h> 

#include "cfsccontactactionmenuimpl.h"

#include "fsccontactactionmenuuids.hrh"

#include "cfsccontactactionmenumodelimpl.h"

#include "tfsccontactactionmenuconstructparameters.h"

#include "cfsccontactactionmenulist.h"

#include "cfsccontactactionmenuitemimpl.h"

#include "cfsccontactactionmenucasitemimpl.h"

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KFscContactActionMenuImplImpUid, 

                                CFscContactActionMenuImpl::NewL )

    };

// ======== LOCAL FUNCTIONS ========

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

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

// CFscContactActionMenuImpl::NewL

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

//

CFscContactActionMenuImpl* CFscContactActionMenuImpl::NewL(

    TAny* aParams )

    {

    FUNC_LOG;

    TFscContactActionMenuConstructParameters* params = 

        reinterpret_cast< TFscContactActionMenuConstructParameters* >( aParams );

    CFscContactActionMenuImpl* self = 

        new (ELeave) CFscContactActionMenuImpl( *params );

    CleanupStack::PushL( self );

    self->ConstructL( *params );

    CleanupStack::Pop( self );

    return self;

    }

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

// CFscContactActionMenuImpl::~CFscContactActionMenuImpl

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

//

CFscContactActionMenuImpl::~CFscContactActionMenuImpl()

    {

    FUNC_LOG;

    delete iModel;

    delete iList;

    delete iWait;

    delete iTextResolver;

    delete iDummyMenuItem;

    }

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

// CFscContactActionMenuImpl::ExecuteL

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

//

TFscActionMenuResult CFscContactActionMenuImpl::ExecuteL( 

    TFscContactActionMenuPosition aPosition, TInt aIndex, MFsActionMenuPositionGiver* aPositionGiver)

    {

    FUNC_LOG;

    // Initialise some member variables

    iExit = EFalse;

    iMenuResult = EFscMenuDismissed;

    iError = KErrNone;

    // Check if menu is empty

    if ( iModel->VisibleItemCount() > 0 )

        {         

        iList = CFscContactActionMenuList::NewL( 

            this, iModel, ( iMode == EFscContactActionMenuModeAI ), aPositionGiver, iOpenedFromMR );

        // Execute menu

        TRAP( iError, DoExecuteL( aPosition, aIndex ) );

        // Delete iList

        iSelectedItemIndex = iList->SelectedItemIndex();

        delete iList;

        iList = NULL;

        User::LeaveIfError( iError );

        }

    return iMenuResult;

    }

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

// CFscContactActionMenuImpl::Dismiss

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

//

void CFscContactActionMenuImpl::Dismiss( TBool aSlide )

    {

    FUNC_LOG;

    iExit = !aSlide;

    iMenuResult = EFscMenuDismissed;

    // cancel action execution if running

    // needs to be canceled to close select popup dialog

    if ( iIsActionExecuting )

        {

        iModel->Service()->CancelExecute();

        iIsActionExecuting = EFalse;

        }

    DoDismiss();

    }

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

// CFscContactActionMenuImpl::Model

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

//

MFscContactActionMenuModel& CFscContactActionMenuImpl::Model()

    {

    FUNC_LOG;

    return *iModel; 

    }

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

// CFscContactActionMenuImpl::FocusedItemIndex

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

//

TInt CFscContactActionMenuImpl::FocusedItemIndex()

    {

    FUNC_LOG;

    TInt result = iSelectedItemIndex;

    if ( iList != NULL )

        {

        result = iList->SelectedItemIndex();

        }

    return result;

    }

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

// CFscContactActionMenuImpl::FocusedItem

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

//

CFscContactActionMenuItem& CFscContactActionMenuImpl::FocusedItem()

    {

    FUNC_LOG;

    TInt i = FocusedItemIndex();

    TInt err = KErrNone;

    CFscContactActionMenuItem* focusedItem = NULL;

    TRAP( err, focusedItem = &(iModel->ItemL( i )) );

    if ( err != KErrNone )

        {

        CCoeEnv::Static()->HandleError( err );

        focusedItem = iDummyMenuItem;

        }

    return *focusedItem;

    }

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

// CFscContactActionMenuImpl::HandleListEvent

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

//

void CFscContactActionMenuImpl::HandleListEvent( 

    TFscContactActionMenuListEvent aEvent,

    TInt aError )

    {

    FUNC_LOG;

    switch ( aEvent )

        {

        case EFscMenuEventItemClicked:

            {

            HandleItemClick();

            break;

            }

        case EFscMenuEventError:

            {

            iError = aError;

            //break not needed because menu will be dismissed

            }

        case EFscMenuEventExitKey:

            {

            iExit = ETrue;

            //break not needed because menu will be dismissed

            }

        case EFscMenuEventCloseKey:

            {

            iMenuResult = EFscMenuDismissed;

            DoDismiss();

            break;

            }

        case EFscMenuEventMenuHidden:

            {

            StopWait();

            // Hide Cba and fade

            HideMenuCba();

            iFader.FadeBehindPopup( this, iList, EFalse );

            break;

            }

        case EFscMenuLayoutChanged:

            {

            Dismiss( iExit );

            break;

            }

        default:

            {

            // nothing to do here

            break;

            }    

        }

    } 

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

// CFscContactActionMenuImpl::CountFadedComponents

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

//

TBool CFscContactActionMenuImpl::IsOperationCompleted()

    {

    FUNC_LOG;

    return isExecuteCompleted;

    }

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

// CFscContactActionMenuImpl::SetOpenedFromMR

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

// 

void CFscContactActionMenuImpl::SetOpenedFromMR( TBool aOpenedFromMR )

    {

    iOpenedFromMR = aOpenedFromMR;

    }

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

// CFscContactActionMenuImpl::CountFadedComponents

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

//

TInt CFscContactActionMenuImpl::CountFadedComponents()

    {

    FUNC_LOG;

    TInt count = 1;

    if ( iList )

        {

        count++;

        }

    return count;

    }

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

// CFscContactActionMenuImpl::FadedComponent

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

//

CCoeControl* CFscContactActionMenuImpl::FadedComponent(TInt aIndex)

    {

    FUNC_LOG;

    CCoeControl* cntrl = NULL;

    switch (aIndex)

        {

        case 0:

            {

            cntrl = iButtonGroupContainer;

            break;

            }        

        case 1:

            {

            cntrl = iList;

            break;

            }

        default:

            {

            cntrl = NULL;

            break;

            }

        }

    return cntrl;    

    }

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

// CFscContactActionMenuImpl::FadedComponent

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

//

void CFscContactActionMenuImpl::HandleGainingForeground()

    {

    FUNC_LOG;

    }

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

// CFscContactActionMenuImpl::FadedComponent

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

//

void CFscContactActionMenuImpl::HandleLosingForeground()

    {

    FUNC_LOG;

    }

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

// CFscContactActionMenuImpl::ProcessCommandL

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

//

void CFscContactActionMenuImpl::ProcessCommandL(TInt aCommandId)

    {

    FUNC_LOG;

    if ( isExecuteCompleted )

        {

        switch ( aCommandId )

            {

            case EAknSoftkeyCancel:

                {

                iMenuResult = EFscMenuDismissed;

                DoDismiss();

                break;

                }

            case EAknSoftkeySelect:

                {

                HandleItemClick();

                break;

                }

            default:

                {

                // Nothing to do

                break;

                }    

            }

        }

    }

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

// CFscContactActionMenuImpl::CFscContactActionMenuImpl

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

//

CFscContactActionMenuImpl::CFscContactActionMenuImpl( 

    const TFscContactActionMenuConstructParameters& aParams ) 

    : CFscContactActionMenu(), iMode(aParams.iMode),

      iSelectedItemIndex( 0 ), isExecuteCompleted( ETrue ),

      iOpenedFromMR( EFalse )

    {

    FUNC_LOG;

    }

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

// CFscContactActionMenuImpl::ConstructL

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

//

void CFscContactActionMenuImpl::ConstructL(

    const TFscContactActionMenuConstructParameters& aParams )

    {

    FUNC_LOG;

    iModel = CFscContactActionMenuModelImpl::NewL( aParams.iService );

    iWait = new ( ELeave ) CActiveSchedulerWait();

    iTextResolver = CTextResolver::NewL( *CCoeEnv::Static() );

    iDummyMenuItem = CFscContactActionMenuItemImpl::NewL();

    iDummyMenuItem->SetImplementationUid( KNullUid );

    }   

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

// CFscContactActionMenuImpl::DoExecuteL

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

//

void CFscContactActionMenuImpl::DoExecuteL( 

    TFscContactActionMenuPosition aPosition,

    TInt aIndex )

    {

    FUNC_LOG;

    // Show list

    iList->ShowL( aPosition, aIndex );

    ShowMenuCbaL();

    iFader.FadeBehindPopup( this, iList, ETrue );

    // Wait untill dialog is hidden again

    StartWait(); 

    }

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

// CFscContactActionMenuImpl::DoDismiss

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

//

void CFscContactActionMenuImpl::DoDismiss()

    {

    FUNC_LOG;

    if ( iList )

        {

        iList->Hide( !iExit ); // If no instant exit, slide

        }

    }

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

// CFscContactActionMenuImpl::StartWait

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

//

void CFscContactActionMenuImpl::StartWait()

    {

    FUNC_LOG;

    iWait->Start();

    }

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

// CFscContactActionMenuImpl::StopWait

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

//

void CFscContactActionMenuImpl::StopWait()

    {

    FUNC_LOG;

    if ( iWait->IsStarted() )

        {

        iWait->AsyncStop();

        }

    }

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

// CFscContactActionMenuImpl::ShowMenuCbaL

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

//

void CFscContactActionMenuImpl::ShowMenuCbaL()

    {

    FUNC_LOG;

    TInt cbaResource = 0;

    if ( iList->ItemCount() > 0)

        {

        cbaResource = R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT;

        }

    else

        {

        cbaResource = R_AVKON_SOFTKEYS_CANCEL;

        }    

    iButtonGroupContainer = CEikButtonGroupContainer::NewL( 

        CEikButtonGroupContainer::ECba,

        CEikButtonGroupContainer::EHorizontal,

        this, cbaResource, *iList, 

        CEikButtonGroupContainer::EDelayActivation );

    }

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

// CFscContactActionMenuImpl::HideMenuCba

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

//

void CFscContactActionMenuImpl::HideMenuCba()

    {

    FUNC_LOG;

    delete iButtonGroupContainer;

    iButtonGroupContainer = NULL;

    }  

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

// CFscContactActionMenuImpl::HandleItemClick

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

//

void CFscContactActionMenuImpl::HandleItemClick()

    {

    FUNC_LOG;

    TInt selectedItemIndex = FocusedItemIndex();

    TInt itemCount = iModel->VisibleItemCount();

    if ( selectedItemIndex >= 0 && selectedItemIndex < itemCount )

        {

        // Check type of selected item

        CFscContactActionMenuItem* baseItem = NULL;

        TRAP( iError, baseItem = &iModel->VisibleItemL( selectedItemIndex ) );

		if ( iError == KErrNone )

		    {

            // Check type of selected item

            CFscContactActionMenuCasItemImpl* item =

                dynamic_cast<CFscContactActionMenuCasItemImpl*>( baseItem );

            if ( item != NULL )

                {

                iMenuResult = EFscCasItemSelectedAndExecuting;

                TUid actionUid = item->ImplementationUid();

                isExecuteCompleted = EFalse;

                iIsActionExecuting = ETrue;

                TRAP( iError,

                    iModel->Service()->ExecuteL( actionUid, this ) );

                }

            else

                {

                // Custom item is not executed by the menu

                iMenuResult = EFscCustomItemSelected;

                DoDismiss();

                }

		    }

		if ( iError != KErrNone )

            {

            // Show error note

            TPtrC buf;

            buf.Set( iTextResolver->ResolveErrorString( iError ) );

            if ( buf.Length() > 0 )

                {

                CAknWarningNote* note = new CAknWarningNote();

                if ( note )

                    {

                    // If error string was found and note execution is 

                    // successfull iError will be KErrNone. Otherwise 

                    // iError will be delivered to the client application

                    TRAP( iError, note->ExecuteLD( buf ) );

                    }

                else

                    {

                    iError = KErrNoMemory;

                    }