/*

* 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 );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CmPluginVpnNextLayerSelectDlg::CmPluginVpnNextLayerSelectDlg

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

//

CmPluginVpnNextLayerSelectDlg::CmPluginVpnNextLayerSelectDlg(

                                        CCmPluginBaseEng& aCmPluginBaseEng,

                                        RArray<TUint32>& aBindableMethods,

                                        TBool& aSnapSelected,

                                        TUint32& aNextLayerId )

    : 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()

    {

    iResourceReader.Close();

    if ( iMenuBar )

        {

        HideMenu();

        CEikonEnv::Static()->EikAppUi()->RemoveFromStack( iMenuBar );

        delete iMenuBar;

        iMenuBar = NULL;

        }

    delete iMyListBox; iMyListBox = NULL;

    }

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

// CmPluginVpnNextLayerSelectDlg::ConstructL

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

//

void CmPluginVpnNextLayerSelectDlg::ConstructL()

    {

    LoadResourceL( KPluginVPNResDirAndFileName );

    InitialiseL();

    SetTextsAndIconsL();

    }

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

// CmPluginVpnNextLayerSelectDlg::InitialiseL

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

// 

void CmPluginVpnNextLayerSelectDlg::InitialiseL()

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::InitialiseL" );

    // get the EasyWlan id if it's supported

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        iEasyWlanId = iCmManager.EasyWlanIdL();

        }

    // Listbox

    iMyListBox = new ( ELeave ) CAknDoubleLargeGraphicPopupMenuStyleListBox;

    CAknPopupList::ConstructL( 

                            iMyListBox, 

                            R_SOFTKEYS_OPTIONS_CANCEL__SELECT, 

                            AknPopupLayouts::EMenuDoubleLargeGraphicWindow );

    TInt flags = 0;

    iMyListBox->ConstructL( this, flags );

    iMyListBox->CreateScrollBarFrameL( ETrue );

    iMyListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                    CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    // Menu

    CEikMenuBar* newMenuBar = new ( ELeave ) CEikMenuBar();

    CleanupStack::PushL( newMenuBar );

    newMenuBar->ConstructL( this, NULL, R_VPN_REAL_CM_SELECTION_MENUBAR );

    iMyEikonEnv.EikAppUi()->AddToStackL( newMenuBar, 

                                         ECoeStackPriorityMenu, 

                                         ECoeStackFlagRefusesFocus );

    iMenuBar = newMenuBar;

    CleanupStack::Pop( newMenuBar ); // ownership taken by 'this'

    }

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

// CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL

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

//

void CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL()

    {

    LOGGER_ENTERFN( "CmPluginVpnNextLayerSelectDlg::SetTextsAndIconsL" );

    // Title

    SetTitleL( *StringLoader::LoadLC( 

                            R_QTN_NETW_CONSET_PRMPT_VPN_REAL_CONNECTION ) );

    CleanupStack::PopAndDestroy(); // header

    // Item text array

    CDesCArray* itemArray =

                new ( ELeave ) CDesCArrayFlat( KCmArrayMediumGranularity );

    CleanupStack::PushL( itemArray );

    iMyListBox->Model()->SetItemTextArray( itemArray ); // ownership taken

    iMyListBox->Model()->SetOwnershipType( ELbmOwnsItemArray );

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

    // Icon array

    CArrayPtr<CGulIcon>* icons =

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

    CleanupStack::PushL( icons );

    iMyListBox->ItemDrawer()->FormattedCellData()->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[ iListBox->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[ iListBox->CurrentItemIndex() ];

            if ( destId != KDestItemUncategorized )

                {

                TUint32 attribute = ECmNextLayerSNAPId;

                // EasyWlan was selected

                if ( destId == KDestItemEasyWlan )

                    {

                    attribute = ECmNextLayerIapId;

                    destId = iEasyWlanId;

                    }

                iCmPluginBaseEng.SetIntAttributeL( attribute, destId );

                AttemptExitL( ETrue );

                break;

                }

            // For uncategorised destinations, flow through to ECmManagerUiCmdCMSelect

            }

        case ECmManagerUiCmdCMSelect:

            {

            // select a connection method from the highlighted destination

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

            TUint32 cmId (0);

            if ( ShowCMSelectionDlgL( destId, cmId ) )

                {

                iCmPluginBaseEng.SetIntAttributeL( ECmNextLayerIapId, cmId );

                AttemptExitL( ETrue );

                }

            else

                {

                CancelPopup();

                }

            break;

            }

        case EAknCmdHelp:

            {

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

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

            }

            break;

        case EAknSoftkeyBack:

            {

            CancelPopup();

            break;

            } 

        default:

            {

            CAknPopupList::ProcessCommandL( aCommandId );

            break;

            }

        }

    }

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

// CmPluginVpnNextLayerSelectDlg::OfferKeyEventL

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

//

TKeyResponse CmPluginVpnNextLayerSelectDlg::OfferKeyEventL( 

                                                const TKeyEvent& aKeyEvent, 

                                                TEventCode aType )    

    {

    TKeyResponse retVal ( EKeyWasNotConsumed );

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

    switch ( aKeyEvent.iScanCode )

        {

        case EStdKeyDownArrow:

        case EStdKeyUpArrow:

            {

            // If focus is on the 'uncategorised' destination, 

            // change the soft key to 'Open'

            if ( highlighted == KDestItemUncategorized )

                {

                ButtonGroupContainer()->SetCommandL( 

                                ECmManagerUiCmdDestSelect, 

                                *( StringLoader::LoadLC( R_QTN_MSK_OPEN ) ) 

                                                    );

                ButtonGroupContainer()->DrawDeferred();

                CleanupStack::PopAndDestroy();

                }

            else

                {

                ButtonGroupContainer()->SetCommandL( 

                               ECmManagerUiCmdDestSelect, 

                               *( StringLoader::LoadLC( R_QTN_MSK_SELECT ) ) 

                                                    );

                ButtonGroupContainer()->DrawDeferred();

                CleanupStack::PopAndDestroy();

                }

            break;

            }

        case EStdKeyNo:

            {

            CancelPopup();

            return EKeyWasConsumed;

            }

        default:

            {

            // If focus is on the 'uncategorised' destination, 

            // change the soft key to 'Open'

            if ( highlighted == KDestItemUncategorized )

                {