/*

* Copyright (c) 2006-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 CCmDlg

*

*/

#include <avkon.hrh>

#include <eikdef.h>

#include <eikenv.h>

#include <eikedwin.h>

#include <cmmanager.rsg>

#include <data_caging_path_literals.hrh>

#include <aknnavide.h>

#include <akntitle.h>

#include <eikmenup.h>

#include <StringLoader.h>

#include <AknIconArray.h>

#include <aknnavilabel.h>

#include <cmmanager.mbg>

#include <cmpluginembdestinationdef.h>

#include <featmgr.h>

#include <hlplch.h>

#include <csxhelp/cp.hlp.hrh>

#include "cmdlg.h"

#include "cmmanager.hrh"

#include "cmlistitem.h"

#include "cmlistitemlist.h"

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include "cmdestinationimpl.h"

#include <cmcommonui.h>

#include <cmcommonconstants.h>

#include <cmpbasesettingsdlg.h>

#include "cmwizard.h"

#include "selectdestinationdlg.h"

#include <cmmanagerdef.h>

#include <mcmdexec.h>

#include "ccmdexec.h"

#include "destdlg.h"

#include "cmlogger.h"

#include "cmconnsettingsuiimpl.h"

using namespace CMManager;

using namespace CommsDat;

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

// CCmDlg::ConstructAndRunLD

// Constructs the dialog and runs it.

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

//

TInt CCmDlg::ConstructAndRunLD(  TUint32 aHighlight,

                                          TUint32& aSelected )

    {

    CleanupStack::PushL( this );

    iHighlight = aHighlight;

    iSelected = &aSelected;

    ConstructL( R_CM_MENUBAR );

    PrepareLC( R_CM_DIALOG );

    CleanupStack::Pop( this );

    iModel = new( ELeave )CCmListboxModel();

    iCmDestinationImpl = iCmManager->DestinationL( iDestUid );

    iInfoPopupNoteController = CAknInfoPopupNoteController::NewL();

    // Trace changes in CommsDat

    iCmManager->WatcherRegisterL( this );

    return RunLD();

    }

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

// CCmDlg::NewL()

// Two-phase dconstructor, second phase is ConstructAndRunLD

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

//

CCmDlg* CCmDlg::NewL(CCmManagerImpl* aCmManager, TUint32 aDestUid,

                     CDestDlg* aDestDlg)

    {

    CCmDlg* self = new (ELeave) CCmDlg( aCmManager, aDestUid, aDestDlg );

    return self;

    }

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

// CCmDlg::CCmDlg()

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

//

CCmDlg::CCmDlg( CCmManagerImpl* aCmManager, TUint32 aDestUid,

                CDestDlg* aDestDlg )

    : iModelPassed( EFalse )

    , iCmManager( aCmManager )

    , iDestUid ( aDestUid )

    , iPrioritising ( EFalse )

    , iExitReason( KDialogUserBack )

    , iEscapeArrived( EFalse )

    , iExitduringProcessing( EFalse )

    , iBackduringProcessing( EFalse )

    , iDestDlg( aDestDlg )

    {

    }

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

// CCmDlg::~CCmDlg

// Destructor

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

//

CCmDlg::~CCmDlg()

    {

    // iModel is deleted by the ListBox because LB owns the model...

    // of course only after we passed ownership...

    if ( !iModelPassed )

        {

        delete iModel;

        }

    delete iNaviDecorator;

    if ( iTitlePane )

        {

        // set old text back, if we have it...

        if ( iOldTitleText )

            {

            TRAP_IGNORE( iTitlePane->SetTextL( *iOldTitleText ) );

            delete iOldTitleText; iOldTitleText = NULL;

            }

        }    

    delete iOldTitleText;

    if(iCmDestinationImpl)

        {

        delete iCmDestinationImpl;

        iCmDestinationImpl = NULL;

        }    

    if ( iInfoPopupNoteController )

        {

        delete iInfoPopupNoteController;

        }

    if( iCmWizard )

        {

        delete iCmWizard;

        }

    iItemIndex.Close();

    delete iCmdExec;

    iCmdExec = NULL;

    }

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

// CCmDlg::PreLayoutDynInitL();

// called by framework before dialog is shown

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

//

void CCmDlg::PreLayoutDynInitL()

    {

    iListbox = STATIC_CAST( CCmListbox*, Control( KCmListboxId ) );

    iListbox->CreateScrollBarFrameL( ETrue );

    iListbox->ScrollBarFrame()->SetScrollBarVisibilityL

                        ( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    iListbox->SetListBoxObserver( this );

    iListbox->Model()->SetItemTextArray( iModel );

    iModelPassed = ETrue;

    InitTextsL();

    HandleListboxDataChangeL();

    iListbox->HandleItemAdditionL();

    if ( iHighlight )

        {

        iListbox->ScrollToMakeItemVisible( iHighlight );

        iListbox->SetCurrentItemIndexAndDraw( iHighlight );

        }

    ShowPopupNoteL();        

    }

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

// CCmDlg::DynInitMenuPaneL

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

//

void CCmDlg::DynInitMenuPaneL( TInt aResourceId,

                                        CEikMenuPane* aMenuPane )

    {

    CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane );        

    if ( aResourceId == R_CM_MENU )

        {

    	if (aResourceId == R_CM_MENU && !iCmManager->IsHelpOn())

            {

            aMenuPane->DeleteMenuItem( EAknCmdHelp );		    

            }

        // Menu items

        TBool hideAdd       ( EFalse );

        TBool hideRename    ( EFalse );

        TBool hideDelete    ( EFalse );

        TBool hideCopy      ( EFalse );

        TBool hideMove      ( EFalse );

        TBool hidePrioritise( EFalse );

        // Edit, Rename, Delete and Organise menu items are hidden if:

        // 1. CM List is empty

        // 2. Embedded Destinations

        if ( !( iListbox->Model()->ItemTextArray()->MdcaCount() ) )

            {

            hideRename  = ETrue;

            hideDelete  = ETrue;

            hideCopy = ETrue;

            hideMove = ETrue; 

            }

        // Embedded destinations can be deleted but not edited

        else if ( ( CurrentCML()->GetBoolAttributeL(ECmDestination) ) )

            {

            hideRename  = ETrue;

            }

        // Only one CM in the list OR highlighted CM is a virtual CM

        else if ( ( iListbox->Model()->ItemTextArray()->MdcaCount() == 1 ) )

            {

            hidePrioritise = ETrue;

            }            

        // virtual CMs pointing to destinations

        else if ( CurrentCML()->GetBoolAttributeL( ECmVirtual ) )

            {

            if ( CurrentCML()->GetIntAttributeL( ECmNextLayerSNAPId ) )

                {

                hidePrioritise = ETrue;

                }

            }

        // No available destination to copy/move the CM to

        RArray<TUint32> destinations( KCmArrayMediumGranularity );

        CleanupClosePushL( destinations );

        iCmManager->AllDestinationsL( destinations );

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

            {            

            CCmDestinationImpl* dest = 

                                    iCmManager->DestinationL( destinations[i] );

            CleanupStack::PushL( dest );

            // Not allowed to copy/move CMs into Level1 protected destinations

            if ( dest->ProtectionLevel() != CMManager::EProtLevel1 )

                {

                // iCmDestinationImpl is null in Uncat dlg - ignore

                // Don't count the current destination

                if ( !iCmDestinationImpl || 

                     dest->Id() != iCmDestinationImpl->Id() ) 

                    {

                    hideCopy = EFalse;

                    hideMove = EFalse;

                    CleanupStack::PopAndDestroy( dest );

                    break;

                    }

                }

            CleanupStack::PopAndDestroy( dest );                

            }

        CleanupStack::PopAndDestroy( &destinations );    

        // Show or hide menu items

        if ( aResourceId == R_CM_MENU )

            {            

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmAdd,     hideAdd );

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmRename,  hideRename );            

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmDelete,  hideDelete );    

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmPrioritise, hidePrioritise );

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmMoveToOtherDestination, hideMove );

            aMenuPane->SetItemDimmed( ECmManagerUiCmdCmCopyToOtherDestination, hideCopy ); 

            }

        }   

    }

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

// CCmDlg::InitTextsL

// called before the dialog is shown

// to initialize localized textual data

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

//

void CCmDlg::InitTextsL()

    {

    // set pane text if neccessary...

    // pane text needed if not pop-up...

    HBufC* primary = 

              iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_PRIMARY );

    HBufC* secondary = 

              iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_SECONDARY );

    CDesCArrayFlat* items = new (ELeave) CDesCArrayFlat(2);

    CleanupStack::PushL(items);

    items->AppendL(primary->Des()); 

    items->AppendL(secondary->Des());      

    HBufC* emptyText = 

          StringLoader::LoadLC( R_TWO_STRING_FOR_EMPTY_VIEW , *items);              

    iListbox->View()->SetListEmptyTextL( *emptyText );    

    CleanupStack::PopAndDestroy( emptyText );

    CleanupStack::PopAndDestroy( items );

    CleanupStack::PopAndDestroy( secondary );

    CleanupStack::PopAndDestroy( primary );

    iStatusPane = iEikonEnv->AppUiFactory()->StatusPane();

    iTitlePane = ( CAknTitlePane* )iStatusPane->ControlL(

                                          TUid::Uid( EEikStatusPaneUidTitle ) );

    iOldTitleText = iTitlePane->Text()->AllocL();

    HBufC* name = iCmDestinationImpl->NameLC();

    iTitlePane->SetTextL( *name );

    CleanupStack::PopAndDestroy( name );

    iNaviPane = ( CAknNavigationControlContainer* ) 

                    iStatusPane->ControlL( 

                            TUid::Uid( EEikStatusPaneUidNavi ) );

    iNaviDecorator = iNaviPane->CreateNavigationLabelL( KNullDesC );

    iNaviPane->PushL( *iNaviDecorator );

    }

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

// CCmDlg::SetNoOfCMsL

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

//

void CCmDlg::SetNoOfCMsL(TInt aCount)

    {

    if ( iNaviDecorator )

        {

        if ( iNaviDecorator->ControlType() == 

             CAknNavigationDecorator::ENaviLabel)

            {

            CAknNaviLabel* naviLabel = 

                            (CAknNaviLabel*)iNaviDecorator->DecoratedControl();

            if (aCount)

                {

                HBufC* title = NULL;

                if (aCount == 1)

                    {

                    title = StringLoader::LoadLC( 

                                           R_CMMANAGERUI_NAVI_ONE_CONN_METHOD );

                    }

                else

                    {

                    title = StringLoader::LoadLC( 

                                           R_CMMANAGERUI_NAVI_MANY_CONN_METHODS, 

                                           aCount );

                    }

                naviLabel->SetTextL(*title);

                  CleanupStack::PopAndDestroy( title );

                }

            else

                {

                naviLabel->SetTextL(KNullDesC);

                }

            iNaviPane->PushL( *iNaviDecorator );

            }

        }

    }

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

// CCmDlg::CreateCustomControlL

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

//

SEikControlInfo CCmDlg::CreateCustomControlL( TInt aControlType )

    {

    SEikControlInfo controlInfo;

    controlInfo.iTrailerTextId = 0;

    controlInfo.iFlags = 0;

    if ( aControlType == KCmListboxType )

        {

        controlInfo.iControl = new ( ELeave ) CCmListbox;

        }

    else

        {

        controlInfo.iControl = NULL;

        }

    return controlInfo;

    }

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

// CCmDlg::OkToExitL

// Good to know : EAknSoftkeyCancel is never called, because

// EEikDialogFlagNotifyEsc flag is not set in the resource.

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

//

TBool CCmDlg::OkToExitL( TInt aButtonId )

    {

    LOGGER_ENTERFN( "CCmDlg::OkToExitL" );

    // Translate the button presses into commands for the appui & current

    // view to handle

    // Dialog should not exit

    TBool retVal( EFalse );

    switch ( aButtonId )

        {

        case EAknSoftkeyOk:

        case ECmManagerUiCmdCmEdit:

            {

            if ( !iProcessing )

                {

                if ( CMCount() )

                    {

                    iProcessing = ETrue;

                    ProcessCommandL( aButtonId );

                    iProcessing = EFalse;

                    }

                else

                    {

                    iProcessing = ETrue;

                    AddConnectionMethodL();

                    iProcessing = EFalse;

                    }

                }

            break;

            }

        case EAknSoftkeyClear:

            {

            ProcessCommandL( aButtonId );

            break;

            }

        case ECmManagerUiCmdCmPrioOk:

            {

            if ( iPrioritising )

                {

                FinishPriorizingL( ETrue );

                }

            break;

            }               

       case ECmManagerUiCmdCmPrioCancel:            

            {

            if ( !MenuShowing() )            

                {

                if ( iPrioritising )

                    {

                    FinishPriorizingL( EFalse );

                    }

                }            

            break;

            }           

        case ECmManagerUiCmdCmUserExit:

            {

            iCmManager->WatcherUnRegister();

            iExitReason = KDialogUserExit;

            break;

            }

        case EAknSoftkeyBack:

            {

            iCmManager->WatcherUnRegister();

            if ( !iProcessing )

                {

                *iSelected = 0;

                TryExitL( iExitReason );

                }

            else

                {

                iBackduringProcessing = ETrue;

                }

            break;

            }

        default:

            {

            if ( !iProcessing )

                {

                if ( aButtonId == EAknSoftkeyOptions )

                    {

                    DisplayMenuL();

                    }

                else

                    {

                    retVal = ETrue;

                    }

                }

            if ( iProcessing )

                {

                iExitduringProcessing = ETrue;

                if( aButtonId == KDialogUserExit )

                    {

                    retVal = ETrue;

                    } 

                }

            break;

            }

        }

    return retVal;

    }

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

// CCmDlg::HandleListBoxEventL

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

//

void CCmDlg::HandleListBoxEventL( CEikListBox* /*aListBox*/,

                                  TListBoxEvent aEventType )

    {

    LOGGER_ENTERFN( "CCmDlg::HandleListBoxEventL" );

    switch ( aEventType )

        {

        case EEventEnterKeyPressed:

            {

            if ( iPrioritising )

                {

                FinishPriorizingL( ETrue );

                }

            else

                {

                if ( !iProcessing )

                    {

                    delete iCmdExec;

                    iCmdExec = NULL;

                    iCmdExec = new (ELeave) CCmdExec(*this);

                    iCmdExec->Execute();

                    }

                }           

            break;