1 /*

     2 * Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of CCmDlg

    15 *

    16 */

    17 

    18 #include <avkon.hrh>

    19 #include <eikdef.h>

    20 #include <eikenv.h>

    21 #include <eikedwin.h>

    22 #include <cmmanager.rsg>

    23 #include <data_caging_path_literals.hrh>

    24 #include <aknnavide.h>

    25 #include <akntitle.h>

    26 #include <eikmenup.h>

    27 #include <StringLoader.h>

    28 #include <AknIconArray.h>

    29 #include <aknnavilabel.h>

    30 #include <cmmanager.mbg>

    31 #include <cmpluginembdestinationdef.h>

    32 #include <featmgr.h>

    33 

    34 #include <hlplch.h>

    35 #include <csxhelp/cp.hlp.hrh>

    36 

    37 #include "cmdlg.h"

    38 #include "cmmanager.hrh"

    39 #include "cmlistitem.h"

    40 #include "cmlistitemlist.h"

    41 #include <cmpluginbaseeng.h>

    42 #include <cmpluginbase.h>

    43 #include "cmdestinationimpl.h"

    44 #include <cmcommonui.h>

    45 #include <cmcommonconstants.h>

    46 #include <cmpbasesettingsdlg.h>

    47 #include "cmwizard.h"

    48 #include "selectdestinationdlg.h"

    49 #include <cmmanagerdef.h>

    50 #include <mcmdexec.h>

    51 #include "ccmdexec.h"

    52 #include "destdlg.h"

    53 #include "cmlogger.h"

    54 #include "cmconnsettingsuiimpl.h"

    55 

    56 using namespace CMManager;

    57 using namespace CommsDat;

    58 

    59 // ---------------------------------------------------------------------------

    60 // CCmDlg::ConstructAndRunLD

    61 // Constructs the dialog and runs it.

    62 // ---------------------------------------------------------------------------

    63 //

    64 TInt CCmDlg::ConstructAndRunLD(  TUint32 aHighlight,

    65                                           TUint32& aSelected )

    66     {

    67     CleanupStack::PushL( this );

    68 

    69     iHighlight = aHighlight;

    70     iSelected = &aSelected;

    71     

    72     ConstructL( R_CM_MENUBAR );

    73     PrepareLC( R_CM_DIALOG );

    74     CleanupStack::Pop( this );

    75 

    76     iModel = new( ELeave )CCmListboxModel();

    77     

    78     iCmDestinationImpl = iCmManager->DestinationL( iDestUid );

    79     

    80     iInfoPopupNoteController = CAknInfoPopupNoteController::NewL();

    81     

    82     // Trace changes in CommsDat

    83     iCmManager->WatcherRegisterL( this );

    84         

    85     return RunLD();

    86     }

    87     

    88 // ---------------------------------------------------------------------------

    89 // CCmDlg::NewL()

    90 // Two-phase dconstructor, second phase is ConstructAndRunLD

    91 // ---------------------------------------------------------------------------

    92 //

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

    94                      CDestDlg* aDestDlg)

    95     {

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

    97     return self;

    98     }

    99     

   100 // ---------------------------------------------------------------------------

   101 // CCmDlg::CCmDlg()

   102 // ---------------------------------------------------------------------------

   103 //

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

   105                 CDestDlg* aDestDlg )

   106     : iModelPassed( EFalse )

   107     , iCmManager( aCmManager )

   108     , iDestUid ( aDestUid )

   109     , iPrioritising ( EFalse )

   110     , iExitReason( KDialogUserBack )

   111     , iEscapeArrived( EFalse )

   112     , iExitduringProcessing( EFalse )

   113     , iBackduringProcessing( EFalse )

   114     , iDestDlg( aDestDlg )

   115     {

   116     }

   117     

   118 // ---------------------------------------------------------------------------

   119 // CCmDlg::~CCmDlg

   120 // Destructor

   121 // ---------------------------------------------------------------------------

   122 //

   123 CCmDlg::~CCmDlg()

   124     {

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

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

   127     if ( !iModelPassed )

   128         {

   129         delete iModel;

   130         }

   131         

   132     delete iNaviDecorator;

   133     

   134     if ( iTitlePane )

   135         {

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

   137         if ( iOldTitleText )

   138             {

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

   140             delete iOldTitleText; iOldTitleText = NULL;

   141             }

   142         }    

   143         

   144     delete iOldTitleText;

   145     

   146     if(iCmDestinationImpl)

   147         {

   148         delete iCmDestinationImpl;

   149         iCmDestinationImpl = NULL;

   150         }    

   151     

   152     if ( iInfoPopupNoteController )

   153         {

   154         delete iInfoPopupNoteController;

   155         }

   156         

   157     if( iCmWizard )

   158         {

   159         delete iCmWizard;

   160         }

   161     iItemIndex.Close();

   162     

   163     delete iCmdExec;

   164     iCmdExec = NULL;

   165     }

   166 

   167 // ---------------------------------------------------------------------------

   168 // CCmDlg::PreLayoutDynInitL();

   169 // called by framework before dialog is shown

   170 // ---------------------------------------------------------------------------

   171 //

   172 void CCmDlg::PreLayoutDynInitL()

   173     {

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

   175     iListbox->CreateScrollBarFrameL( ETrue );

   176     iListbox->ScrollBarFrame()->SetScrollBarVisibilityL

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

   178     iListbox->SetListBoxObserver( this );

   179 

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

   181     iModelPassed = ETrue;

   182     InitTextsL();

   183     HandleListboxDataChangeL();

   184     iListbox->HandleItemAdditionL();

   185     

   186     if ( iHighlight )

   187         {

   188         iListbox->ScrollToMakeItemVisible( iHighlight );

   189         iListbox->SetCurrentItemIndexAndDraw( iHighlight );

   190         }    

   191     }

   192     

   193 // --------------------------------------------------------------------------

   194 // CCmDlg::DynInitMenuPaneL

   195 // --------------------------------------------------------------------------

   196 //

   197 void CCmDlg::DynInitMenuPaneL( TInt aResourceId,

   198                                         CEikMenuPane* aMenuPane )

   199     {

   200     CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane );        

   201     if ( aResourceId == R_CM_MENU )

   202         {

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

   204             {

   205             aMenuPane->DeleteMenuItem( EAknCmdHelp );		    

   206             }

   207         // Menu items

   208     	TBool hideEdit      ( EFalse );

   209         TBool hideAdd       ( EFalse );

   210         TBool hideRename    ( EFalse );

   211         TBool hideDelete    ( EFalse );

   212         TBool hideCopy      ( EFalse );

   213         TBool hideMove      ( EFalse );

   214         TBool hidePrioritise( EFalse );

   215            

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

   217         // 1. CM List is empty

   218         // 2. Embedded Destinations

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

   220             {

   221             hidePrioritise = ETrue;

   222             hideEdit = ETrue;

   223             hideRename  = ETrue;

   224             hideDelete  = ETrue;

   225             hideCopy = ETrue;

   226             hideMove = ETrue;

   227             }

   228         // Embedded destinations can be deleted but not edited

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

   230             {

   231             hideRename  = ETrue;

   232             }

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

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

   235             {

   236             hidePrioritise = ETrue;

   237             }            

   238         // virtual CMs pointing to destinations

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

   240             {

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

   242                 {

   243                 hidePrioritise = ETrue;

   244                 }

   245             }

   246      

   247         // Show or hide menu items

   248         if ( aResourceId == R_CM_MENU )

   249             {            

   250             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmEdit,    hideEdit );

   251             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmAdd,     hideAdd );

   252             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmRename,  hideRename );            

   253             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmDelete,  hideDelete );    

   254             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmPrioritise, hidePrioritise );

   255             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmMoveToOtherDestination, hideMove );

   256             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmCopyToOtherDestination, hideCopy ); 

   257             }

   258         }   

   259     }

   260     

   261 // ---------------------------------------------------------------------------

   262 // CCmDlg::InitTextsL

   263 // called before the dialog is shown

   264 // to initialize localized textual data

   265 // ---------------------------------------------------------------------------

   266 //

   267 void CCmDlg::InitTextsL()

   268     {

   269     // set pane text if neccessary...

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

   271     HBufC* primary = 

   272               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_PRIMARY );

   273     HBufC* secondary = 

   274               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_SECONDARY );

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

   276     CleanupStack::PushL(items);

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

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

   279     HBufC* emptyText = 

   280           StringLoader::LoadLC( R_TWO_STRING_FOR_EMPTY_VIEW , *items);              

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

   282     CleanupStack::PopAndDestroy( emptyText );

   283     CleanupStack::PopAndDestroy( items );

   284     CleanupStack::PopAndDestroy( secondary );

   285     CleanupStack::PopAndDestroy( primary );

   286 

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

   288     iTitlePane = ( CAknTitlePane* )iStatusPane->ControlL(

   289                                           TUid::Uid( EEikStatusPaneUidTitle ) );

   290 

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

   292     HBufC* name = iCmDestinationImpl->NameLC();

   293     iTitlePane->SetTextL( *name );

   294     CleanupStack::PopAndDestroy( name );

   295 

   296     iNaviPane = ( CAknNavigationControlContainer* ) 

   297                     iStatusPane->ControlL( 

   298                             TUid::Uid( EEikStatusPaneUidNavi ) );

   299     iNaviDecorator = iNaviPane->CreateNavigationLabelL( KNullDesC );

   300     iNaviPane->PushL( *iNaviDecorator );

   301     }

   302 

   303 // ---------------------------------------------------------------------------

   304 // CCmDlg::SetNoOfCMsL

   305 // ---------------------------------------------------------------------------

   306 //

   307 

   308 void CCmDlg::SetNoOfCMsL(TInt aCount)

   309     {

   310     if ( iNaviDecorator )

   311         {

   312         if ( iNaviDecorator->ControlType() == 

   313              CAknNavigationDecorator::ENaviLabel)

   314             {

   315             CAknNaviLabel* naviLabel = 

   316                             (CAknNaviLabel*)iNaviDecorator->DecoratedControl();

   317             if (aCount)

   318                 {

   319                 HBufC* title = NULL;

   320                 

   321                 if (aCount == 1)

   322                     {

   323                     title = StringLoader::LoadLC( 

   324                                            R_CMMANAGERUI_NAVI_ONE_CONN_METHOD );

   325                     }

   326                 else

   327                     {

   328                     title = StringLoader::LoadLC( 

   329                                            R_CMMANAGERUI_NAVI_MANY_CONN_METHODS, 

   330                                            aCount );

   331                     }

   332                     

   333                 naviLabel->SetTextL(*title);

   334                   CleanupStack::PopAndDestroy( title );

   335                 }

   336             else

   337                 {

   338                 naviLabel->SetTextL(KNullDesC);

   339                 }

   340                 

   341             iNaviPane->PushL( *iNaviDecorator );

   342             }

   343         }

   344       

   345     }

   346 

   347 //----------------------------------------------------------

   348 // CCmDlg::CreateCustomControlL

   349 //----------------------------------------------------------

   350 //

   351 SEikControlInfo CCmDlg::CreateCustomControlL( TInt aControlType )

   352     {

   353     SEikControlInfo controlInfo;

   354     controlInfo.iTrailerTextId = 0;

   355     controlInfo.iFlags = 0;

   356     if ( aControlType == KCmListboxType )

   357         {

   358         controlInfo.iControl = new ( ELeave ) CCmListbox;

   359         }

   360     else

   361         {

   362         controlInfo.iControl = NULL;

   363         }

   364     return controlInfo;

   365     }

   366 

   367 // ---------------------------------------------------------------------------

   368 // CCmDlg::OkToExitL

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

   370 // EEikDialogFlagNotifyEsc flag is not set in the resource.

   371 // ---------------------------------------------------------------------------

   372 //

   373 TBool CCmDlg::OkToExitL( TInt aButtonId )

   374     {

   375     LOGGER_ENTERFN( "CCmDlg::OkToExitL" );

   376 

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

   378     // view to handle

   379     // Dialog should not exit

   380     TBool retVal( EFalse );

   381     

   382     switch ( aButtonId )

   383         {

   384         case EAknSoftkeyOk:

   385         case ECmManagerUiCmdCmEdit:

   386             {

   387             if ( !iProcessing )

   388                 {

   389                 if ( CMCount() )

   390                     {

   391                     iProcessing = ETrue;

   392                     ProcessCommandL( aButtonId );

   393                     iProcessing = EFalse;

   394                     }

   395                 else

   396                     {

   397                     iProcessing = ETrue;

   398                     AddConnectionMethodL();

   399                     iProcessing = EFalse;

   400                     }

   401                 }

   402             break;

   403             }

   404         case EAknSoftkeyClear:

   405             {

   406             ProcessCommandL( aButtonId );

   407             break;

   408             }

   409         case ECmManagerUiCmdCmPrioOk:

   410             {

   411             if ( iPrioritising )

   412                 {

   413                 FinishPriorizingL( ETrue );

   414                 }

   415                 

   416             break;

   417             }               

   418        case ECmManagerUiCmdCmPrioCancel:            

   419             {

   420             if ( !MenuShowing() )            

   421                 {

   422                 if ( iPrioritising )

   423                     {

   424                     FinishPriorizingL( EFalse );

   425                     }

   426                 }            

   427             break;

   428             }           

   429         case ECmManagerUiCmdCmUserExit:

   430             {

   431             iCmManager->WatcherUnRegister();

   432                         

   433             iExitReason = KDialogUserExit;

   434             break;

   435             }

   436         case EAknSoftkeyBack:

   437             {

   438             iCmManager->WatcherUnRegister();

   439             

   440             if ( !iProcessing )

   441                 {

   442                 *iSelected = 0;

   443                 TryExitL( iExitReason );

   444                 }

   445             else

   446                 {

   447                 iBackduringProcessing = ETrue;

   448                 }

   449             break;

   450             }

   451         default:

   452             {

   453             if ( !iProcessing )

   454                 {

   455                 if ( aButtonId == EAknSoftkeyOptions )

   456                     {

   457                     DisplayMenuL();

   458                     }

   459                 else

   460                     {

   461                     retVal = ETrue;

   462                     }

   463                 }

   464             if ( iProcessing )

   465                 {

   466                 iExitduringProcessing = ETrue;

   467                 if( aButtonId == KDialogUserExit )

   468                     {

   469                     retVal = ETrue;

   470                     } 

   471                 }

   472             break;

   473             }

   474         }

   475     return retVal;

   476     }

   477 

   478 // ---------------------------------------------------------------------------

   479 // CCmDlg::HandleListBoxEventL

   480 // ---------------------------------------------------------------------------

   481 //

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

   483                                   TListBoxEvent aEventType )

   484     {

   485     LOGGER_ENTERFN( "CCmDlg::HandleListBoxEventL" );

   486 

   487     switch ( aEventType )

   488         {

   489         case EEventEnterKeyPressed:

   490             {

   491             if ( iPrioritising )

   492                 {

   493                 FinishPriorizingL( ETrue );

   494                 }

   495             else

   496                 {

   497                 if ( !iProcessing )

   498                     {

   499                     delete iCmdExec;

   500                     iCmdExec = NULL;

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

   502                     iCmdExec->Execute();

   503                     }

   504                 }           

   505             break;            

   506             }

   507         case EEventItemSingleClicked:

   508             {

   509             if ( !iProcessing )

   510                 {

   511                 delete iCmdExec;

   512                 iCmdExec = NULL;

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

   514                 iCmdExec->Execute();

   515                 }

   516             break;

   517             }

   518         case EEventEditingStarted:

   519             {

   520             break;

   521             }

   522         case EEventEditingStopped:

   523             {

   524             break;

   525             }

   526         default:

   527             {

   528             break;

   529             };

   530         };

   531     }

   532        

   533     

   534 // ---------------------------------------------------------------------------

   535 // CCmDlg::ProcessCommandL

   536 // ---------------------------------------------------------------------------

   537 //

   538 void CCmDlg::ProcessCommandL( TInt aCommandId )

   539     {

   540     LOGGER_ENTERFN( "CCmDlg::ProcessCommandL" );

   541 

   542     if ( MenuShowing() )

   543         {

   544         HideMenu();

   545         }

   546 

   547     switch ( aCommandId )

   548         {        

   549         // Connection Method Modification Commands

   550         case ECmManagerUiCmdCmAdd:

   551             {

   552             if ( !iProcessing )

   553                 {

   554                 iProcessing = ETrue;

   555                 TRAPD( err, AddConnectionMethodL() );

   556                 // Memory full

   557                 if (err == KLeaveWithoutAlert || err == KErrNoMemory)

   558                     {

   559                     iProcessing = EFalse;

   560                     return;

   561                     }

   562                 iProcessing = EFalse;

   563 

   564                 if ( iBackduringProcessing )

   565                     {

   566                     iBackduringProcessing = EFalse;

   567                     TryExitL( KDialogUserBack );

   568                     }

   569                 }

   570             break;

   571             }

   572 

   573         case ECmManagerUiCmdCmRename:            

   574             {

   575             RenameConnectionMethodL();

   576             break;

   577             }

   578             

   579         case EAknSoftkeyClear:

   580         case ECmManagerUiCmdCmDelete:            

   581             {

   582             if ( iPrioritising )

   583                 {

   584                 // Delete cannot be done if priorising has started.

   585                 break;

   586                 }

   587             DeleteCurrentCmL();         

   588             break;

   589             }

   590             

   591         case ECmManagerUiCmdCmPrioritise:            

   592             {

   593             PrioritiseConnectionMethodL();

   594             break;

   595             }

   596             

   597         case ECmManagerUiCmdCmCopyToOtherDestination:            

   598             {

   599             CopyConnectionMethodL();            

   600             break;

   601             }

   602             

   603         case ECmManagerUiCmdCmMoveToOtherDestination:            

   604             {            

   605             MoveConnectionMethodL();

   606             break;

   607             }

   608             

   609         case EAknSoftkeyOk:

   610         case ECmManagerUiCmdCmEdit:

   611             {

   612             EditConnectionMethodL();

   613             break;

   614             }   

   615 

   616         // Button Selection commands

   617         case EAknSoftkeyOptions:

   618             {

   619             DisplayMenuL();

   620             break;

   621             }

   622             

   623         case ECmManagerUiCmdCmUserExit:

   624             {

   625             iExitReason = KDialogUserExit;

   626             }

   627             

   628         case EAknSoftkeyBack:

   629             {

   630             if (!iProcessing)

   631                 {

   632                 *iSelected = 0;

   633                 TryExitL( iExitReason );

   634                 }

   635             break;

   636             }

   637         case EAknCmdHelp:

   638             {

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

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

   641             }

   642             break;

   643 

   644         default:

   645             {

   646             break;

   647             }

   648         }

   649     }

   650 

   651 // ---------------------------------------------------------------------------

   652 // CCmDlg::DeleteCurrentCmL

   653 // ---------------------------------------------------------------------------

   654 //

   655 void CCmDlg::DeleteCurrentCmL( )

   656     {

   657     LOGGER_ENTERFN( "CCmDlg::DeleteCurrentCmL" );

   658 

   659     TCmDefConnValue oldConn;

   660     if (iCmManager->IsDefConnSupported())

   661         {

   662         iCmManager->ReadDefConnL( oldConn );

   663         }

   664     CCmPluginBase* cm = CurrentCML();

   665     if ( !cm )

   666     	{

   667     	return;

   668     	}

   669 

   670     if ( cm->GetBoolAttributeL( ECmProtected ) )

   671         {

   672         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   673                                 TCmCommonUi::ECmErrorNote );

   674                                 

   675         return;

   676         }

   677    

   678     if ( cm->GetBoolAttributeL( ECmIsLinked ) )//same check as KErrLocked below

   679         {

   680         TCmCommonUi::ShowNoteL( 

   681                             R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   682                             TCmCommonUi::ECmErrorNote );

   683         

   684         return;

   685         }

   686    

   687     if ( cm->GetBoolAttributeL( ECmConnected ) )//same check as KErrInUse below

   688         {

   689         TCmCommonUi::ShowNoteL( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   690                                 TCmCommonUi::ECmErrorNote );

   691         

   692         return;

   693         }

   694 

   695     // EKOA-74KC3L: check if it is the last CM in a destination being referenced

   696     // by a VPN

   697     if ( iCmDestinationImpl &&

   698          iCmDestinationImpl->ConnectionMethodCount() == 1 )

   699         {

   700         // it is definitely the last, but is it referenced?

   701 

   702         // for each IAP in CM manager

   703         //   1. check if it is virtual

   704         //      if not => goto 1.

   705         //      if yes:

   706         //      2. check if it links to the destination of this CM

   707         //         if yes => carryOn = EFalse, ERROR

   708         //         if not: carryOn = ETrue

   709 

   710         CommsDat::CMDBRecordSet<CommsDat::CCDIAPRecord>* iaps = 

   711                                                     iCmManager->AllIapsL();

   712         

   713         CleanupStack::PushL( iaps );

   714         

   715         TBool carryOn = ETrue;

   716         TUint32 destId = iCmDestinationImpl->Id();

   717 

   718         // for each IAP in CM manager

   719         for ( TInt i = 0; carryOn && i < iaps->iRecords.Count(); ++i )

   720             {

   721             CommsDat::CCDIAPRecord* rec = (*iaps)[i];

   722             TUint32 bearerType = 0;

   723             

   724             TRAP_IGNORE( bearerType = 

   725                              iCmManager->BearerTypeFromIapRecordL( rec ) );

   726             if ( !bearerType )

   727                 {

   728                 continue;

   729                 }

   730                 

   731             // check if it is virtual

   732             if ( iCmManager->GetBearerInfoBoolL( bearerType, ECmVirtual ) )

   733                 {

   734                 // check if it links to the current destination

   735                 CCmPluginBase* plugin = NULL;            

   736                 TRAP_IGNORE( plugin = iCmManager->GetConnectionMethodL( 

   737                                                            rec->RecordId() ) );

   738 

   739                 if ( !plugin )

   740                     {

   741                     continue;

   742                     }

   743                 

   744                 if ( plugin->IsLinkedToSnap( destId ) )

   745                     {

   746                     // the CM links to this destination, deletion not allowed

   747                     carryOn = EFalse;

   748                     }

   749 

   750                 delete plugin;

   751                 }

   752                     

   753             }

   754             

   755         CleanupStack::PopAndDestroy( iaps );

   756         

   757         if ( !carryOn )

   758             {

   759             TCmCommonUi::ShowNoteL( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   760                                 TCmCommonUi::ECmErrorNote );

   761             return;            

   762             }

   763         

   764         }

   765     

   766 

   767     // If it's an embedded destination, show a warning

   768     TBool showCmDeleteQuery( ETrue );

   769     if ( cm->GetBoolAttributeL( ECmDestination ) )

   770         {

   771         if ( TCmCommonUi::ShowConfirmationQueryL(

   772                             R_CMMANAGERUI_QUEST_EMBEDDED_DEST_DELETE ) )

   773             {

   774             // user wants to delete, set flag to avoid 2nd query message

   775             showCmDeleteQuery = EFalse;

   776             }

   777         else

   778             {

   779             return; // user cancelled delete request

   780             }

   781         }

   782 

   783     HBufC* cmName = cm->GetStringAttributeL( ECmName );

   784     CleanupStack::PushL( cmName );

   785     

   786     // Query for CM deletion - which will be skipped in the case of embedded 

   787     // destintations

   788     // Protected CM's cannot be deleted either

   789     if ( !showCmDeleteQuery || iAlreadyConfirmedDelete ||

   790          TCmCommonUi::ShowConfirmationQueryL( 

   791                                     R_CMMANAGERUI_QUEST_CM_DELETE,

   792                                     *cmName ) )

   793         {

   794         TInt err = KErrNone;

   795         if ( iCmDestinationImpl )

   796             {

   797             TRAP( err, iCmDestinationImpl->DeleteConnectionMethodL( *cm ) );

   798             }

   799         else

   800             {

   801             TRAP( err, (void)cm->DeleteL( ETrue ) );

   802             }

   803         

   804         switch ( err )

   805             {

   806             case KErrInUse: //shouldn't get here, already checked above

   807                 {

   808                 TCmCommonUi::ShowNoteL

   809                     ( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   810                     TCmCommonUi::ECmErrorNote );

   811                 }

   812                 break;

   813                 

   814             case KErrLocked://shouldn't get here, already checked above

   815                 {

   816                 TCmCommonUi::ShowNoteL

   817                     ( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   818                       TCmCommonUi::ECmErrorNote );

   819                 }

   820                 break;

   821                 

   822             case KErrNone:

   823                 {

   824                 if ( iCmDestinationImpl )

   825                     {

   826                     iCmDestinationImpl->UpdateL();

   827                     }

   828                 if (iCmManager->IsDefConnSupported())

   829                     {

   830                     iDestDlg->ShowDefaultConnectionNoteL( oldConn );

   831                     }

   832                 HandleListboxDataChangeL();

   833                 }

   834                 break;

   835 

   836             default:

   837                 {

   838                 }

   839                 break;

   840             }

   841         }

   842 

   843     CleanupStack::PopAndDestroy( cmName );

   844     }

   845 

   846 // --------------------------------------------------------------------------

   847 // CCmDlg::RenameConnectionMethodL    

   848 // --------------------------------------------------------------------------

   849 //

   850 void CCmDlg::RenameConnectionMethodL()

   851     {

   852     LOGGER_ENTERFN( "CCmDlg::RenameConnectionMethodL" );

   853 

   854     CCmPluginBase* cm = CurrentCML();

   855     if ( !cm )

   856         {

   857         return;

   858         }

   859 

   860     if ( cm->GetBoolAttributeL( ECmProtected ) )

   861         {

   862         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   863                                 TCmCommonUi::ECmErrorNote );

   864         return;

   865         }

   866 

   867     if ( CurrentCmInUseL() )

   868         {

   869         return;

   870         } 

   871            

   872     TBuf<KConnMethodNameMaxLength> buf;

   873     

   874     HBufC* cmName = cm->GetStringAttributeL(ECmName);

   875     CleanupStack::PushL(cmName);

   876     buf.Copy(*cmName);

   877     

   878     // Saves the recent naming method and set it to "Not accept"

   879     TUint32 savedNM = cm->GetIntAttributeL( ECmNamingMethod );

   880     cm->SetIntAttributeL( ECmNamingMethod, ENamingNotAccept );

   881 

   882     // Asks the new name

   883     TBool go = ETrue;

   884     TInt ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   885                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   886                                                 buf );

   887     

   888     // While the name is not unique or cancel pressed

   889     while( ret && go )

   890         {

   891         // Tries to save the nem name. If it is not unique

   892         // then ret == KErrArgument

   893         TRAPD( err, cm->SetStringAttributeL( ECmName, buf ) );

   894 

   895         if( KErrArgument == err )

   896             {

   897             // Opens a info note

   898             HBufC* noteLine = StringLoader::LoadLC(

   899                     R_CMMANAGERUI_INFO_CM_ALREADY_IN_USE, buf );

   900 

   901             TCmCommonUi::ShowNoteL( *noteLine, TCmCommonUi::ECmInfoNote );

   902 

   903             CleanupStack::PopAndDestroy( noteLine );

   904 

   905             // Asks the new name again

   906             ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   907                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   908                                                 buf );

   909             }

   910         else

   911             {

   912             // New name is unique loop can stop

   913             go = EFalse;

   914             }    

   915         }

   916 

   917     // Sets back the original naming method

   918     cm->SetIntAttributeL( ECmNamingMethod, savedNM );

   919 

   920     // If not cancel pressed the new name is set

   921     if( ret )

   922         {

   923         cm->UpdateL();

   924         

   925         HandleListboxDataChangeL();

   926         }

   927    

   928     CleanupStack::PopAndDestroy( cmName );

   929     }

   930 

   931 // --------------------------------------------------------------------------

   932 // CCmDlg::PrioritiseConnectionMethodL    

   933 // --------------------------------------------------------------------------

   934 //

   935 void CCmDlg::PrioritiseConnectionMethodL()

   936     {

   937     LOGGER_ENTERFN( "CCmDlg::PrioritiseConnectionMethodL" );

   938     

   939     ButtonGroupContainer().SetCommandSetL( R_SOFTKEYS_PRIO_OK_CANCEL__OK );

   940     iListbox->View()->SelectItemL( iListbox->CurrentItemIndex() );

   941     iListbox->View()->DrawItem( iListbox->CurrentItemIndex() );

   942     ButtonGroupContainer().DrawNow();

   943     iPrioritising = ETrue;

   944     iCmToPrioritise = iListbox->CurrentItemIndex();

   945     }

   946 

   947 // --------------------------------------------------------------------------

   948 // CCmDlg::AddConnectionMethodL    

   949 // --------------------------------------------------------------------------

   950 //

   951 void CCmDlg::AddConnectionMethodL()

   952     {

   953     LOGGER_ENTERFN( "CCmDlg::AddConnectionMethodL" );

   954 

   955     // Check first if parent destination is protected

   956     if ( iCmDestinationImpl && 

   957          iCmDestinationImpl->ProtectionLevel() == CMManager::EProtLevel1 )

   958         {

   959         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   960                                 TCmCommonUi::ECmErrorNote );

   961         return;

   962         }

   963 

   964     // Opens a Connection method creation wizard

   965     iCmWizard = new (ELeave) CCmWizard( *iCmManager );

   966 

   967     TInt itemstemp = iListbox->Model()->NumberOfItems();

   968 

   969     TInt ret( KErrNone );

   970     TRAPD( err, ret = iCmWizard->CreateConnectionMethodL( iCmDestinationImpl ) );

   971     if ( err )

   972         {

   973         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   974                 TCmCommonUi::ECmErrorNote );

   975         ret = KErrCancel;

   976         }

   977     delete iCmWizard;

   978     iCmWizard = NULL;

   979 

   980 

   981     // If application wanted to be closed before then RunAppShutter()

   982     // should be called here                

   983     if( iEscapeArrived )

   984         {

   985         ( ( CAknAppUi* )iEikonEnv->EikAppUi() )->RunAppShutter();

   986         }

   987     

   988     if( ret != KErrCancel )

   989         {

   990         iHighlight = ret;

   991 

   992 

   993         // Update the middle soft key if this is the first cm added

   994         if ( CMCount() == 1 )

   995             {

   996             HBufC* text = StringLoader::LoadLC( R_QTN_MSK_EDIT );

   997             ButtonGroupContainer().SetCommandL( ECmManagerUiCmdCmEdit, 

   998                                                     *text );

   999             CleanupStack::PopAndDestroy( text );

  1000             }

  1001         

  1002         //HandleListboxDataChangeL();

  1003         TRAP( err, HandleListboxDataChangeL() );

  1004         if ( err )

  1005             {

  1006             TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1007                     TCmCommonUi::ECmErrorNote );

  1008             return;

  1009             }

  1010         iListbox->HandleItemAdditionL();

  1011     

  1012         if (itemstemp < iListbox->Model()->NumberOfItems())

  1013             {

  1014             //first item cannot be deleted

  1015             iListbox->ScrollToMakeItemVisible( 

  1016                                     iListbox->Model()->NumberOfItems() -1 );

  1017             iListbox->SetCurrentItemIndexAndDraw( iHighlight );

  1018             }

  1019         }

  1020     }

  1021 

  1022 // --------------------------------------------------------------------------

  1023 // CCmDlg::CopyConnectionMethodL    

  1024 // --------------------------------------------------------------------------

  1025 //

  1026 void CCmDlg::CopyConnectionMethodL()

  1027     {

  1028     LOGGER_ENTERFN( "CCmDlg::CopyConnectionMethodL" );

  1029 

  1030     CCmPluginBase* cm = CurrentCML();

  1031     if ( !cm )

  1032         {

  1033         return;

  1034         }

  1035 

  1036     if ( cm->GetBoolAttributeL( ECmProtected ) ||

  1037         ( iCmDestinationImpl && 

  1038          iCmDestinationImpl->ProtectionLevel() == CMManager::EProtLevel1 ) )

  1039         {

  1040         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1041                                 TCmCommonUi::ECmErrorNote );

  1042         return;

  1043         }

  1044 

  1045     TUint32 destId( 0 );

  1046     

  1047     // build an array of possible parent destinations

  1048     TInt destCount=0;

  1049     TRAPD( retVal, destCount = iCmManager->DestinationCountL() );

  1050     if( retVal != KErrNone || destCount < 1 )

  1051         {

  1052         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_DESTINATION,

  1053                                 TCmCommonUi::ECmErrorNote );

  1054         return;

  1055         }

  1056         

  1057     RArray<TUint32> destArray( iCmManager->DestinationCountL() );

  1058     CleanupClosePushL( destArray );

  1059     

  1060     iCmManager->AllDestinationsL( destArray );

  1061     

  1062     // drop current destination (don't ask why)

  1063     if ( iCmDestinationImpl ) 

  1064         {

  1065         destId = iCmDestinationImpl->Id();

  1066         

  1067         TInt index = destArray.Find( destId );

  1068         if ( index != KErrNotFound )

  1069             {

  1070             destArray.Remove( index );

  1071             }

  1072         }

  1073     

  1074     

  1075     // now filter the destinations

  1076     CurrentCML()->FilterPossibleParentsL( destArray );

  1077 

  1078     // check if there are any remaining destinations

  1079     if ( !destArray.Count() )

  1080         {

  1081         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_VPN_STACKING,

  1082                                 TCmCommonUi::ECmErrorNote );        

  1083         CleanupStack::PopAndDestroy( &destArray );

  1084         return;

  1085         }

  1086     

  1087     // ok, there is at least 1, pop up the dialog

  1088     CSelectDestinationDlg* dlg = CSelectDestinationDlg::NewL( destId, 

  1089                                                               *iCmManager, 

  1090                                                               &destArray );

  1091 

  1092     if ( dlg->ExecuteLD( R_CMMANAGER_LIST_QUERY_WITH_MSGBOX ) )

  1093         {

  1094         CCmDestinationImpl* dest = iCmManager->DestinationL( destId );

  1095         CleanupStack::PushL( dest ); 

  1096         if ( iCmDestinationImpl )

  1097             {

  1098             // create a copy of the current connection method

  1099             CCmPluginBase* cmCopy = cm->CreateCopyL();

  1100             CleanupStack::PushL( cmCopy );

  1101             // store it in commsdat

  1102             cmCopy->UpdateL();

  1103             dest->AddConnectionMethodL( *cmCopy );

  1104             

  1105             CleanupStack::PopAndDestroy( cmCopy );

  1106             }

  1107         else

  1108             {

  1109             iCmManager->CopyConnectionMethodL( *dest, *( cm ) );

  1110             }

  1111 

  1112         // Rare but UpdateL can leave that cause crash

  1113         TRAPD( err, dest->UpdateL() );

  1114         if( err < 0 )

  1115             {

  1116             CLOG_WRITE_1( "CCmDlg::CopyConnectionMethodL UpdateL: %d", err );

  1117             }

  1118     

  1119         CleanupStack::PopAndDestroy( dest );

  1120         HandleListboxDataChangeL();                             

  1121         }

  1122     else

  1123         {

  1124         CleanupStack::PopAndDestroy( &destArray );

  1125         User::Leave( KErrCancel );

  1126         }

  1127 

  1128     CleanupStack::PopAndDestroy( &destArray );

  1129     }

  1130 

  1131 // --------------------------------------------------------------------------

  1132 // CCmDlg::MoveConnectionMethodL

  1133 // --------------------------------------------------------------------------