/*

* Copyright (c) 2006 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:  Popup for selecting the underlying connection method or 

*                destination for a VPN connection method

*

*/

// includes

#include <badesca.h> // arrays

#include <gulicon.h> // icons

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <featmgr.h>

#include <cmpluginvpn.mbg>

#include <cmpluginvpnui.rsg>

#include <cmmanager.rsg>

#include <cmmanager.mbg> 

#include <eikenv.h>

#include <aknlists.h>

#include <eikfrlb.h> // CEikFormattedCellListBox

#include <aknradiobuttonsettingpage.h>

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include <hlplch.h>

#include <csxhelp/cp.hlp.hrh>

#include "cmlogger.h"

#include "cmdestinationimpl.h"

#include "cmmanagerimpl.h"

#include "cmpvpnnextlayerselectdlg.h"

#include "cmvpncommonconstants.h"

#include <cmcommonconstants.h>

#include <cmpluginvpndef.h>

using namespace CMManager;

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

// CmPluginVpnNextLayerSelectDlg::NewL

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

//

CmPluginVpnNextLayerSelectDlg* CmPluginVpnNextLayerSelectDlg::NewL( 

                                        CCmPluginBaseEng& aCmPluginBaseEng,

                                        RArray<TUint32>& aBindableMethods,

                                        TBool& aSnapSelected,

                                        TUint32& aNextLayerId )

    {

    CmPluginVpnNextLayerSelectDlg* self = 

            new ( ELeave ) CmPluginVpnNextLayerSelectDlg( aCmPluginBaseEng,

                                                          aBindableMethods,

                                                          aSnapSelected,

                                                          aNextLayerId,

                                                          0 );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CmPluginVpnNextLayerSelectDlg::CmPluginVpnNextLayerSelectDlg

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

//

CmPluginVpnNextLayerSelectDlg::CmPluginVpnNextLayerSelectDlg(

                                        CCmPluginBaseEng& aCmPluginBaseEng,

                                        RArray<TUint32>& aBindableMethods,

                                        TBool& aSnapSelected,

                                        TUint32& aNextLayerId,

                                        TInt aDummyIndex )

    : CAknListQueryDialog( &aDummyIndex )

    , iMyEikonEnv( *CEikonEnv::Static() )

    , iCmPluginBaseEng( aCmPluginBaseEng )

    , iSnapSelected( aSnapSelected )

    , iNextLayerId( aNextLayerId )

    , iResourceReader( *CCoeEnv::Static() )

    , iDestinations( aBindableMethods )

    , iEasyWlanId(0)  

    , iCmManager( iCmPluginBaseEng.CmMgr() ) 

    , iUncatItems( EFalse )

    {

    ;

    }

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

// CmPluginVpnNextLayerSelectDlg::~CmPluginVpnPolicySelectionDlg

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

//

CmPluginVpnNextLayerSelectDlg::~CmPluginVpnNextLayerSelectDlg()

    {

    if (  iAsyncCancel )

        {

        delete  iAsyncCancel;

        iAsyncCancel = NULL;

        }

    iResourceReader.Close();

    }

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

// CmPluginVpnNextLayerSelectDlg::ConstructL

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

//

void CmPluginVpnNextLayerSelectDlg::ConstructL()

    {    

    LoadResourceL( KPluginVPNResDirAndFileName );

    // get the EasyWlan id if it's supported

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        iEasyWlanId = iCmManager.EasyWlanIdL();

        }   

    }

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

// CmPluginVpnNextLayerSelectDlg::CancelAsynchronouslyL

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

TInt CmPluginVpnNextLayerSelectDlg::CancelAsynchronouslyL( TAny* aObject )

    {

    CmPluginVpnNextLayerSelectDlg* myself =

        static_cast< CmPluginVpnNextLayerSelectDlg* >( aObject );

    myself->TryExitL( EAknSoftkeyCancel );

    return 0;

    }

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

// CmPluginVpnNextLayerSelectDlg::PreLayoutDynInitL

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

//

void CmPluginVpnNextLayerSelectDlg::PreLayoutDynInitL()

    {

    CAknDialog::ConstructL( R_VPN_REAL_CM_SELECTION_MENUBAR );

    // Let the base class do its job first

    CAknListQueryDialog::PreLayoutDynInitL();

    SetTextsAndIconsL();

    }

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

// CmPluginVpnNextLayerSelectDlg::OkToExitL

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

//

TBool CmPluginVpnNextLayerSelectDlg::OkToExitL( TInt aButtonId )

    {

    TBool result = EFalse;

    if ( aButtonId == EAknSoftkeyDone  || aButtonId == EAknSoftkeyOk )

        {

        result = ETrue;

        }

    else if ( aButtonId == EAknSoftkeySelect )

        {

        ProcessCommandL( ECmManagerUiCmdDestSelect );

        }    

    else if ( aButtonId == EAknSoftkeyOptions )

        {

        ProcessCommandL( EAknSoftkeyOptions );

        }

    else if ( aButtonId == EAknSoftkeyBack || aButtonId == EAknSoftkeyCancel )

        {

        result = ETrue;

        }

    else

        {

        }

    return result;

    }

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

// CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL

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

//

void CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL()

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL" );

    // Item text array

    CDesCArray* itemArray =

                new ( ELeave ) CDesCArrayFlat( KCmArrayMediumGranularity );

    CleanupStack::PushL( itemArray );

    SetItemTextArray( itemArray ); // ownership taken

    SetOwnershipType( ELbmOwnsItemArray );

    CleanupStack::Pop( itemArray ); // as ownership is taken

    // Icon array

    CArrayPtr<CGulIcon>* icons =

         new ( ELeave ) CArrayPtrFlat<CGulIcon>( KCmArrayMediumGranularity );

    CleanupStack::PushL( icons );

    SetIconArrayL( icons );

    // ownership taken by SetIconArrayL!

    CleanupStack::Pop( icons ); // as ownership is taken

    // Step through the Destinations - do not show:

    // Parent Destinations or Destinations with no non-virtual CMs

    // Show Uncategorised if valid and EasyWlan if supported

    TInt destCount = iDestinations.Count();

    for ( TInt i = 0; i < destCount; i++ )

        {        

        switch ( iDestinations[i] )

            {

            case KDestItemUncategorized:

                {

                // Append 'Uncategorised' if necessary

                AppendUncatDestinationL( *itemArray, *icons );

                break;

                }

            case KDestItemEasyWlan:

                {

                // Append 'EasyWlan' if supported

                TRAPD( err, AppendEasyWlanL( *itemArray, *icons ) );

                if ( err != KErrNotSupported )

                    {

                    User::LeaveIfError( err );

                    }

                break;

                }

            // normal destination

            default:

                {

                CCmDestinationImpl* dest = 

                iCmManager.DestinationL( iDestinations[i] );

                CleanupStack::PushL( dest );

                TInt numCms = dest->ConnectionMethodCount();        

                AppendDestinationTextsL( *dest,numCms, *itemArray, *icons );                

                CleanupStack::PopAndDestroy( dest );

                break;

                }                    

            }

        }

    }

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

// CmPluginVpnNextLayerSelectDlg::AppendDestinationsTextsL

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

//

void CmPluginVpnNextLayerSelectDlg::AppendDestinationTextsL(

                                            CCmDestinationImpl& aDestination,

                                            TInt aNumCms,

                                            CDesCArray& aItems,

                                            CArrayPtr<CGulIcon>& aIcons )

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::AppendDestinationL" );

    // icon

    CGulIcon* icon = ( CGulIcon* ) aDestination.IconL();

    CleanupStack::PushL( icon );

    aIcons.AppendL( icon );

    TInt iconIndex = aIcons.Count() - 1;

    CleanupStack::Pop( icon ); // icon array took over ownership

    // compile the list item

    HBufC* firstLine = aDestination.NameLC();

    HBufC* secondLine;

    if ( aNumCms == 1 )

        {

        secondLine = StringLoader::LoadLC(

                        R_CMMANAGERUI_CONN_METHODS_AMOUNT_ONE );

        }

    else

        {

        secondLine = StringLoader::LoadLC( 

                        R_CMMANAGERUI_CONN_METHODS_AMOUNT_MANY,

                        aNumCms );

        }

    HBufC* item = FormatListItemTextsLC( *firstLine, 

                                         *secondLine,

                                         iconIndex );

    aItems.AppendL( *item );

    CleanupStack::PopAndDestroy( item );

    CleanupStack::PopAndDestroy( secondLine );

    CleanupStack::PopAndDestroy( firstLine );

    }

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

// CmPluginVpnNextLayerSelectDlg::AppendUncatDestinationL

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

//

void CmPluginVpnNextLayerSelectDlg::AppendUncatDestinationL( 

                                                CDesCArray& aItems,

                                                CArrayPtr<CGulIcon>& aIcons )

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::AppendUncatDestinationL" );

    TParse mbmFile;

    User::LeaveIfError( mbmFile.Set( KManagerIconFilename, 

                        &KDC_APP_BITMAP_DIR, 

                        NULL ) );

    // icon

    CGulIcon* icon = AknsUtils::CreateGulIconL(

                AknsUtils::SkinInstance(), 

                KAknsIIDQgnPropSetConnDestUncategorized,

                mbmFile.FullName(), 

                EMbmCmmanagerQgn_prop_set_conn_dest_uncategorized, 

                EMbmCmmanagerQgn_prop_set_conn_dest_uncategorized_mask );

    CleanupStack::PushL( icon );

    aIcons.AppendL( icon );

    CleanupStack::Pop( icon );  // icon array took over ownership

    TInt iconIndex = aIcons.Count() - 1;

    // remove virtual CMs

    RArray<TUint32> uncatCms ( KCmArraySmallGranularity );    

    iCmManager.ConnectionMethodL( uncatCms );

    CleanupClosePushL( uncatCms );

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

        {

        TInt bearerType = iCmManager.GetConnectionMethodInfoIntL( 

                                        uncatCms[i], ECmBearerType );

        if ( iCmManager.GetBearerInfoBoolL( bearerType, ECmVirtual ) )

            {

            uncatCms.Remove(i);

            i--;

            }        

        }

    // second line text

    HBufC* secondLine;            

    if ( uncatCms.Count() == 1 )

        {

        secondLine = StringLoader::LoadLC(

                            R_CMMANAGERUI_CONN_METHODS_AMOUNT_ONE );

        }

    else

        {

        secondLine = StringLoader::LoadLC( 

                            R_CMMANAGERUI_CONN_METHODS_AMOUNT_MANY,

                            uncatCms.Count() );

        }    

    // compile the texts

    HBufC* item = FormatListItemTextsLC( R_CMMANAGERUI_DEST_UNCATEGORIZED,

                                         *secondLine,

                                         iconIndex );            

    aItems.AppendL( *item );

    CleanupStack::PopAndDestroy( item );

    CleanupStack::PopAndDestroy( secondLine );

    CleanupStack::PopAndDestroy( &uncatCms );

    }

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

// CmPluginVpnNextLayerSelectDlg::AppendEasyWlanL

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

//

void CmPluginVpnNextLayerSelectDlg::AppendEasyWlanL( 

                                                CDesCArray& aItems,

                                                CArrayPtr<CGulIcon>& aIcons )

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::AppendEasyWlanL" );

    // icon

    CCmPluginBase* cm = iCmManager.GetConnectionMethodL( iEasyWlanId );

    CleanupStack::PushL( cm );

    CGulIcon* icon = ( CGulIcon* ) cm->GetIntAttributeL( ECmBearerIcon );

    CleanupStack::PushL( icon );

    aIcons.AppendL( icon );  // ownership passed to array

    TInt iconIndex = aIcons.Count() - 1;

    CleanupStack::Pop( icon );

    CleanupStack::PopAndDestroy( cm );

    // compile the texts

    HBufC* easyWlan = FormatListItemTextsLC( 

                                R_QTN_NETW_CONSET_VPN_EASY_WLAN,

                                R_QTN_NETW_CONSET_VPN_EASY_WLAN_PROMPT,

                                iconIndex );

    aItems.AppendL( *easyWlan );

    CleanupStack::PopAndDestroy( easyWlan );

    }

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

// CmPluginVpnNextLayerSelectDlg::DynInitMenuPaneL

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

//

void CmPluginVpnNextLayerSelectDlg::DynInitMenuPaneL( 

                                TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    if ( aResourceId == R_VPN_REAL_CM_SELECTION_MENU )

        {

    	if (!iCmManager.IsHelpOn())

            {

            aMenuPane->DeleteMenuItem( EAknCmdHelp );		    

            }

        TUint32 highlighted = iDestinations[ ListBox()->CurrentItemIndex() ];

        switch ( highlighted )

            {

            case KDestItemUncategorized:

                {

                aMenuPane->SetItemDimmed( ECmManagerUiCmdDestSelect, ETrue );

                break;                

                }

            case KDestItemEasyWlan:

                {

                aMenuPane->SetItemDimmed( ECmManagerUiCmdCMSelect, ETrue );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

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

// CmPluginVpnNextLayerSelectDlg::ProcessCommandL

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

//

void CmPluginVpnNextLayerSelectDlg::ProcessCommandL( TInt aCommandId )

    {

    if ( MenuShowing() )

        {

        HideMenu();

        }

    switch ( aCommandId )

        {

        case EAknSoftkeyOptions:

            {

            DisplayMenuL();

            break;

            }

        case ECmManagerUiCmdDestSelect:

            {            

            TUint32 destId = iDestinations[ ListBox()->CurrentItemIndex() ];

            if ( destId != KDestItemUncategorized )

                {

                TUint32 attribute = ECmNextLayerSNAPId;

                // EasyWlan was selected

                if ( destId == KDestItemEasyWlan )

                    {

                    attribute = ECmNextLayerIapId;

                    destId = iEasyWlanId;

                    }

                iCmPluginBaseEng.SetIntAttributeL( attribute, destId );

                // We cannot use TryExitL here, since if the pointer event

                // handling is ongoing, i.e., we got here from this class's

                // HandleListBoxEventL, there will be a KERN-EXEC 3 panic.

                // Calling base class HandleListBoxEventL will exit the

                // dialog asynchronously with return value ETrue.

                CAknListQueryDialog::HandleListBoxEventL( ListBox(),

                     EEventItemSingleClicked );

                break;

                }

            // For uncategorised destinations, flow through to ECmManagerUiCmdCMSelect

            }

        case ECmManagerUiCmdCMSelect:

            {

            // select a connection method from the highlighted destination

            TUint32 destId = iDestinations[ ListBox()->CurrentItemIndex() ];

            TUint32 cmId (0);

            if ( ShowCMSelectionDlgL( destId, cmId ) )

                {

                iCmPluginBaseEng.SetIntAttributeL( ECmNextLayerIapId, cmId );

                // We cannot use TryExitL here, since if the pointer event

                // handling is ongoing, i.e., we got here from this class's

                // HandleListBoxEventL, there will be a KERN-EXEC 3 panic.

                // Calling base class HandleListBoxEventL will exit the

                // dialog asynchronously with return value ETrue.

                CAknListQueryDialog::HandleListBoxEventL( ListBox(),

                                     EEventItemSingleClicked );

                }

            else

                {

                // We need to exit asynchronously, in case we ended up here

                // from HandleListBoxEventL. The callback function will exit

                // the dialog with return value EFalse.

                TCallBack cb( CancelAsynchronouslyL, this );

                iAsyncCancel = new( ELeave ) CAsyncCallBack( cb, CActive::EPriorityHigh );

                iAsyncCancel->CallBack();

                }

            break;

            }

        case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),

                                    iEikonEnv->EikAppUi()->AppHelpContextL() );

            }

            break;

        case EAknSoftkeyBack:

            {

            TryExitL( EAknSoftkeyBack );

            break;

            } 

        default:

            {

            CAknListQueryDialog::ProcessCommandL( aCommandId );

            break;

            }

        }

    }

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

// CmPluginVpnNextLayerSelectDlg::OfferKeyEventL

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

//

TKeyResponse CmPluginVpnNextLayerSelectDlg::OfferKeyEventL( 

                                                const TKeyEvent& aKeyEvent, 

                                                TEventCode aType )    

    {

    TKeyResponse retVal ( EKeyWasNotConsumed );

    TUint highlighted = iDestinations[ ListBox()->CurrentItemIndex() ];

    switch ( aKeyEvent.iScanCode )