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

   111     , iEscapeArrived( EFalse )

   112     , iExitduringProcessing( EFalse )

   113     , iBackduringProcessing( EFalse )

   114     , iDestDlg( aDestDlg )

   115     , iPluginExitExceptionally( EFalse )

   116     {

   117     }

   118     

   119 // ---------------------------------------------------------------------------

   120 // CCmDlg::~CCmDlg

   121 // Destructor

   122 // ---------------------------------------------------------------------------

   123 //

   124 CCmDlg::~CCmDlg()

   125     {

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

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

   128     if ( !iModelPassed )

   129         {

   130         delete iModel;

   131         }

   132         

   133     delete iNaviDecorator;

   134     

   135     if ( iTitlePane )

   136         {

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

   138         if ( iOldTitleText )

   139             {

   140             if ( iExitReason == KDialogUserBack || iPluginExitExceptionally  )

   141                 {

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

   143                 }

   144             delete iOldTitleText; iOldTitleText = NULL;

   145             }

   146         }    

   147         

   148     delete iOldTitleText;

   149     

   150     if(iCmDestinationImpl)

   151         {

   152         delete iCmDestinationImpl;

   153         iCmDestinationImpl = NULL;

   154         }    

   155     

   156     if ( iInfoPopupNoteController )

   157         {

   158         delete iInfoPopupNoteController;

   159         }

   160         

   161     if( iCmWizard )

   162         {

   163         delete iCmWizard;

   164         }

   165     iItemIndex.Close();

   166     

   167     delete iCmdExec;

   168     iCmdExec = NULL;

   169     }

   170 

   171 // ---------------------------------------------------------------------------

   172 // CCmDlg::PreLayoutDynInitL();

   173 // called by framework before dialog is shown

   174 // ---------------------------------------------------------------------------

   175 //

   176 void CCmDlg::PreLayoutDynInitL()

   177     {

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

   179     iListbox->CreateScrollBarFrameL( ETrue );

   180     iListbox->ScrollBarFrame()->SetScrollBarVisibilityL

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

   182     iListbox->SetListBoxObserver( this );

   183 

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

   185     iModelPassed = ETrue;

   186     InitTextsL();

   187     HandleListboxDataChangeL();

   188     iListbox->HandleItemAdditionL();

   189     

   190     if ( iHighlight )

   191         {

   192         iListbox->ScrollToMakeItemVisible( iHighlight );

   193         iListbox->SetCurrentItemIndex( iHighlight );

   194         }    

   195     }

   196     

   197 // --------------------------------------------------------------------------

   198 // CCmDlg::DynInitMenuPaneL

   199 // --------------------------------------------------------------------------

   200 //

   201 void CCmDlg::DynInitMenuPaneL( TInt aResourceId,

   202                                         CEikMenuPane* aMenuPane )

   203     {

   204     CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane );        

   205     

   206     if ( aResourceId == R_CM_MENU )

   207         {

   208     	if ( !iCmManager->IsHelpOn() )

   209             {

   210             aMenuPane->DeleteMenuItem( EAknCmdHelp );		    

   211             }

   212         // Menu items

   213     	TBool hideEdit      ( EFalse );

   214         TBool hideAdd       ( EFalse );

   215         TBool hideRename    ( EFalse );

   216         TBool hideDelete    ( EFalse );

   217         TBool hideCopy      ( EFalse );

   218         TBool hideMove      ( EFalse );

   219         TBool hidePrioritise( EFalse );

   220            

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

   222         // 1. CM List is empty

   223         // 2. Embedded Destinations

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

   225             {

   226             hidePrioritise = ETrue;

   227             hideEdit = ETrue;

   228             hideRename  = ETrue;

   229             hideDelete  = ETrue;

   230             hideCopy = ETrue;

   231             hideMove = ETrue;

   232             }

   233         // Embedded destinations can be deleted but not edited

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

   235             {

   236             hideRename  = ETrue;

   237             }

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

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

   240             {

   241             hidePrioritise = ETrue;

   242             }            

   243         // virtual CMs pointing to destinations

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

   245             {

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

   247                 {

   248                 hidePrioritise = ETrue;

   249                 }

   250             }

   251  

   252         // All item specific options need to be dimmed if in prioritising view

   253         if ( iPrioritising )

   254             {

   255             hideEdit = ETrue;

   256             hideAdd = ETrue;

   257             hideRename = ETrue;

   258             hideDelete = ETrue;

   259             hideCopy = ETrue;

   260             hideMove = ETrue;

   261             hidePrioritise = ETrue;           

   262             }

   263 

   264         // Show or hide menu items

   265         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmEdit,    hideEdit );

   266         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmAdd,     hideAdd );

   267         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmRename,  hideRename );            

   268         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmDelete,  hideDelete );    

   269         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmPrioritise, hidePrioritise );

   270         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmMoveToOtherDestination, hideMove );

   271         aMenuPane->SetItemDimmed( ECmManagerUiCmdCmCopyToOtherDestination, hideCopy ); 

   272         }   

   273     }

   274     

   275 // ---------------------------------------------------------------------------

   276 // CCmDlg::InitTextsL

   277 // called before the dialog is shown

   278 // to initialize localized textual data

   279 // ---------------------------------------------------------------------------

   280 //

   281 void CCmDlg::InitTextsL()

   282     {

   283     // set pane text if neccessary...

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

   285     HBufC* primary = 

   286               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_PRIMARY );

   287     HBufC* secondary = 

   288               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_SECONDARY );

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

   290     CleanupStack::PushL(items);

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

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

   293     HBufC* emptyText = 

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

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

   296     CleanupStack::PopAndDestroy( emptyText );

   297     CleanupStack::PopAndDestroy( items );

   298     CleanupStack::PopAndDestroy( secondary );

   299     CleanupStack::PopAndDestroy( primary );

   300 

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

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

   303                                           TUid::Uid( EEikStatusPaneUidTitle ) );

   304 

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

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

   307     iTitlePane->SetTextL( *name );

   308     CleanupStack::PopAndDestroy( name );

   309 

   310     iNaviPane = ( CAknNavigationControlContainer* ) 

   311                     iStatusPane->ControlL( 

   312                             TUid::Uid( EEikStatusPaneUidNavi ) );

   313     iNaviDecorator = iNaviPane->CreateNavigationLabelL( KNullDesC );

   314     iNaviPane->PushL( *iNaviDecorator );

   315     }

   316 

   317 // ---------------------------------------------------------------------------

   318 // CCmDlg::SetNoOfCMsL

   319 // ---------------------------------------------------------------------------

   320 //

   321 

   322 void CCmDlg::SetNoOfCMsL(TInt aCount)

   323     {

   324     if ( iNaviDecorator )

   325         {

   326         if ( iNaviDecorator->ControlType() == 

   327              CAknNavigationDecorator::ENaviLabel)

   328             {

   329             CAknNaviLabel* naviLabel = 

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

   331             if (aCount)

   332                 {

   333                 HBufC* title = NULL;

   334                 

   335                 if (aCount == 1)

   336                     {

   337                     title = StringLoader::LoadLC( 

   338                                            R_CMMANAGERUI_NAVI_ONE_CONN_METHOD );

   339                     }

   340                 else

   341                     {

   342                     title = StringLoader::LoadLC( 

   343                                            R_CMMANAGERUI_NAVI_MANY_CONN_METHODS, 

   344                                            aCount );

   345                     }

   346                     

   347                 naviLabel->SetTextL(*title);

   348                   CleanupStack::PopAndDestroy( title );

   349                 }

   350             else

   351                 {

   352                 naviLabel->SetTextL(KNullDesC);

   353                 }

   354                 

   355             iNaviPane->PushL( *iNaviDecorator );

   356             }

   357         }

   358       

   359     }

   360 

   361 //----------------------------------------------------------

   362 // CCmDlg::CreateCustomControlL

   363 //----------------------------------------------------------

   364 //

   365 SEikControlInfo CCmDlg::CreateCustomControlL( TInt aControlType )

   366     {

   367     SEikControlInfo controlInfo;

   368     controlInfo.iTrailerTextId = 0;

   369     controlInfo.iFlags = 0;

   370     if ( aControlType == KCmListboxType )

   371         {

   372         controlInfo.iControl = new ( ELeave ) CCmListbox;

   373         }

   374     else

   375         {

   376         controlInfo.iControl = NULL;

   377         }

   378     return controlInfo;

   379     }

   380 

   381 // ---------------------------------------------------------------------------

   382 // CCmDlg::OkToExitL

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

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

   385 // ---------------------------------------------------------------------------

   386 //

   387 TBool CCmDlg::OkToExitL( TInt aButtonId )

   388     {

   389     LOGGER_ENTERFN( "CCmDlg::OkToExitL" );

   390 

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

   392     // view to handle

   393     // Dialog should not exit

   394     TBool retVal( EFalse );

   395     

   396     switch ( aButtonId )

   397         {

   398         case EAknSoftkeyOk:

   399         case ECmManagerUiCmdCmEdit:

   400             {

   401             if ( !iProcessing )

   402                 {

   403                 if ( CMCount() )

   404                     {

   405                     iProcessing = ETrue;

   406                     ProcessCommandL( aButtonId );

   407                     iProcessing = EFalse;

   408                     }

   409                 else

   410                     {

   411                     iProcessing = ETrue;

   412                     AddConnectionMethodL();

   413                     iProcessing = EFalse;

   414                     }

   415                 }

   416             break;

   417             }

   418         case EAknSoftkeyClear:

   419             {

   420             ProcessCommandL( aButtonId );

   421             break;

   422             }

   423         case ECmManagerUiCmdCmPrioOk:

   424             {

   425             if ( iPrioritising )

   426                 {

   427                 FinishPriorizingL( ETrue );

   428                 }

   429                 

   430             break;

   431             }               

   432        case ECmManagerUiCmdCmPrioCancel:            

   433             {

   434             if ( !MenuShowing() )            

   435                 {

   436                 if ( iPrioritising )

   437                     {

   438                     FinishPriorizingL( EFalse );

   439                     }

   440                 }            

   441             break;

   442             }           

   443         case ECmManagerUiCmdCmUserExit:

   444             {

   445             iCmManager->WatcherUnRegister();

   446                         

   447             iExitReason = KDialogUserExit;

   448             break;

   449             }

   450         case EAknSoftkeyBack:

   451             {

   452             iCmManager->WatcherUnRegister();

   453             iExitReason = KDialogUserBack;

   454             

   455             if ( !iProcessing )

   456                 {

   457                 *iSelected = 0;

   458                 TryExitL( iExitReason );

   459                 }

   460             else

   461                 {

   462                 iBackduringProcessing = ETrue;

   463                 }

   464             break;

   465             }

   466         default:

   467             {

   468             if ( !iProcessing )

   469                 {

   470                 if ( aButtonId == EAknSoftkeyOptions )

   471                     {

   472                     DisplayMenuL();

   473                     }

   474                 else

   475                     {

   476                     retVal = ETrue;

   477                     }

   478                 }

   479             if ( iProcessing )

   480                 {

   481                 iExitduringProcessing = ETrue;

   482                 if( aButtonId == KDialogUserExit )

   483                     {

   484                     retVal = ETrue;

   485                     } 

   486                 

   487                 if ( iPluginExitExceptionally )

   488                     {

   489                     retVal = ETrue;

   490                     }

   491                 }

   492             break;

   493             }

   494         }

   495     return retVal;

   496     }

   497 

   498 // ---------------------------------------------------------------------------

   499 // CCmDlg::HandleListBoxEventL

   500 // ---------------------------------------------------------------------------

   501 //

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

   503                                   TListBoxEvent aEventType )

   504     {

   505     LOGGER_ENTERFN( "CCmDlg::HandleListBoxEventL" );

   506 

   507     switch ( aEventType )

   508         {

   509         case EEventEnterKeyPressed:

   510             {

   511             if ( iPrioritising )

   512                 {

   513                 FinishPriorizingL( ETrue );

   514                 }

   515             else

   516                 {

   517                 if ( !iProcessing )

   518                     {

   519                     delete iCmdExec;

   520                     iCmdExec = NULL;

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

   522                     iCmdExec->Execute();

   523                     }

   524                 }           

   525             break;            

   526             }

   527         case EEventItemSingleClicked:

   528             {

   529             if ( !iProcessing )

   530                 {

   531                 delete iCmdExec;

   532                 iCmdExec = NULL;

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

   534                 iCmdExec->Execute();

   535                 }

   536             break;

   537             }

   538         case EEventEditingStarted:

   539             {

   540             break;

   541             }

   542         case EEventEditingStopped:

   543             {

   544             break;

   545             }

   546         default:

   547             {

   548             break;

   549             };

   550         };

   551     }

   552        

   553     

   554 // ---------------------------------------------------------------------------

   555 // CCmDlg::ProcessCommandL

   556 // ---------------------------------------------------------------------------

   557 //

   558 void CCmDlg::ProcessCommandL( TInt aCommandId )

   559     {

   560     LOGGER_ENTERFN( "CCmDlg::ProcessCommandL" );

   561 

   562     if ( MenuShowing() )

   563         {

   564         HideMenu();

   565         }

   566 

   567     switch ( aCommandId )

   568         {        

   569         // Connection Method Modification Commands

   570         case ECmManagerUiCmdCmAdd:

   571             {

   572             if ( !iProcessing )

   573                 {

   574                 iProcessing = ETrue;

   575                 TRAPD( err, AddConnectionMethodL() );

   576                 // Memory full

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

   578                     {

   579                     iProcessing = EFalse;

   580                     return;

   581                     }

   582                 iProcessing = EFalse;

   583 

   584                 if ( iBackduringProcessing )

   585                     {

   586                     iBackduringProcessing = EFalse;

   587                     TryExitL( KDialogUserBack );

   588                     }

   589                 }

   590             break;

   591             }

   592 

   593         case ECmManagerUiCmdCmRename:            

   594             {

   595             RenameConnectionMethodL();

   596             break;

   597             }

   598             

   599         case EAknSoftkeyClear:

   600         case ECmManagerUiCmdCmDelete:            

   601             {

   602             if ( iPrioritising )

   603                 {

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

   605                 break;

   606                 }

   607             DeleteCurrentCmL();         

   608             break;

   609             }

   610             

   611         case ECmManagerUiCmdCmPrioritise:            

   612             {

   613             PrioritiseConnectionMethodL();

   614             break;

   615             }

   616             

   617         case ECmManagerUiCmdCmCopyToOtherDestination:            

   618             {

   619             CopyConnectionMethodL();            

   620             break;

   621             }

   622             

   623         case ECmManagerUiCmdCmMoveToOtherDestination:            

   624             {            

   625             MoveConnectionMethodL();

   626             break;

   627             }

   628             

   629         case EAknSoftkeyOk:

   630         case ECmManagerUiCmdCmEdit:

   631             {

   632             EditConnectionMethodL();

   633             break;

   634             }   

   635 

   636         // Button Selection commands

   637         case EAknSoftkeyOptions:

   638             {

   639             DisplayMenuL();

   640             break;

   641             }

   642             

   643         case ECmManagerUiCmdCmUserExit:

   644             {

   645             if (!iProcessing)

   646                 {

   647                 *iSelected = 0;

   648                 iExitReason = KDialogUserExit;

   649                 TryExitL( iExitReason );

   650                 }

   651             break;

   652             }

   653             

   654         case EAknSoftkeyBack:

   655             {

   656             if (!iProcessing)

   657                 {

   658                 *iSelected = 0;

   659                 iExitReason = KDialogUserBack;

   660                 TryExitL( iExitReason );

   661                 }

   662             break;

   663             }

   664         case EAknCmdHelp:

   665             {

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

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

   668             }

   669             break;

   670 

   671         default:

   672             {

   673             break;

   674             }

   675         }

   676     }

   677 

   678 // ---------------------------------------------------------------------------

   679 // CCmDlg::DeleteCurrentCmL

   680 // ---------------------------------------------------------------------------

   681 //

   682 void CCmDlg::DeleteCurrentCmL( )

   683     {

   684     LOGGER_ENTERFN( "CCmDlg::DeleteCurrentCmL" );

   685 

   686     TCmDefConnValue oldConn;

   687     if (iCmManager->IsDefConnSupported())

   688         {

   689         iCmManager->ReadDefConnL( oldConn );

   690         }

   691     CCmPluginBase* cm = CurrentCML();

   692     if ( !cm )

   693     	{

   694     	return;

   695     	}

   696 

   697     if ( cm->GetBoolAttributeL( ECmProtected ) )

   698         {

   699         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   700                                 TCmCommonUi::ECmErrorNote );

   701                                 

   702         return;

   703         }

   704    

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

   706         {

   707         TCmCommonUi::ShowNoteL( 

   708                             R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   709                             TCmCommonUi::ECmErrorNote );

   710         

   711         return;

   712         }

   713    

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

   715         {

   716         TCmCommonUi::ShowNoteL( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   717                                 TCmCommonUi::ECmErrorNote );

   718         

   719         return;

   720         }

   721 

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

   723     // by a VPN

   724     if ( iCmDestinationImpl &&

   725          iCmDestinationImpl->ConnectionMethodCount() == 1 )

   726         {

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

   728 

   729         // for each IAP in CM manager

   730         //   1. check if it is virtual

   731         //      if not => goto 1.

   732         //      if yes:

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

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

   735         //         if not: carryOn = ETrue

   736 

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

   738                                                     iCmManager->AllIapsL();

   739         

   740         CleanupStack::PushL( iaps );

   741         

   742         TBool carryOn = ETrue;

   743         TUint32 destId = iCmDestinationImpl->Id();

   744 

   745         // for each IAP in CM manager

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

   747             {

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

   749             TUint32 bearerType = 0;

   750             

   751             TRAP_IGNORE( bearerType = 

   752                              iCmManager->BearerTypeFromIapRecordL( rec ) );

   753             if ( !bearerType )

   754                 {

   755                 continue;

   756                 }

   757                 

   758             // check if it is virtual

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

   760                 {

   761                 // check if it links to the current destination

   762                 CCmPluginBase* plugin = NULL;            

   763                 TRAP_IGNORE( plugin = iCmManager->GetConnectionMethodL( 

   764                                                            rec->RecordId() ) );

   765 

   766                 if ( !plugin )

   767                     {

   768                     continue;

   769                     }

   770                 

   771                 if ( plugin->IsLinkedToSnap( destId ) )

   772                     {

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

   774                     carryOn = EFalse;

   775                     }

   776 

   777                 delete plugin;

   778                 }

   779                     

   780             }

   781             

   782         CleanupStack::PopAndDestroy( iaps );

   783         

   784         if ( !carryOn )

   785             {

   786             TCmCommonUi::ShowNoteL( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   787                                 TCmCommonUi::ECmErrorNote );

   788             return;            

   789             }

   790         

   791         }

   792     

   793 

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

   795     TBool showCmDeleteQuery( ETrue );

   796     if ( cm->GetBoolAttributeL( ECmDestination ) )

   797         {

   798         if ( TCmCommonUi::ShowConfirmationQueryL(

   799                             R_CMMANAGERUI_QUEST_EMBEDDED_DEST_DELETE ) )

   800             {

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

   802             showCmDeleteQuery = EFalse;

   803             }

   804         else

   805             {

   806             return; // user cancelled delete request

   807             }

   808         }

   809 

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

   811     CleanupStack::PushL( cmName );

   812     

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

   814     // destintations

   815     // Protected CM's cannot be deleted either

   816     if ( !showCmDeleteQuery || iAlreadyConfirmedDelete ||

   817          TCmCommonUi::ShowConfirmationQueryL( 

   818                                     R_CMMANAGERUI_QUEST_CM_DELETE,

   819                                     *cmName ) )

   820         {

   821         TInt err = KErrNone;

   822         if ( iCmDestinationImpl )

   823             {

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

   825             }

   826         else

   827             {

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

   829             }

   830         

   831         switch ( err )

   832             {

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

   834                 {

   835                 TCmCommonUi::ShowNoteL

   836                     ( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   837                     TCmCommonUi::ECmErrorNote );

   838                 }

   839                 break;

   840                 

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

   842                 {

   843                 TCmCommonUi::ShowNoteL

   844                     ( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   845                       TCmCommonUi::ECmErrorNote );

   846                 }

   847                 break;

   848                 

   849             case KErrNone:

   850                 {

   851                 if ( iCmDestinationImpl )

   852                     {

   853                     iCmDestinationImpl->UpdateL();

   854                     }

   855                 if (iCmManager->IsDefConnSupported())

   856                     {

   857                     iDestDlg->ShowDefaultConnectionNoteL( oldConn );

   858                     }

   859                 HandleListboxDataChangeL();

   860                 iListbox->HandleItemRemovalL();

   861                 }

   862                 break;

   863 

   864             default:

   865                 {

   866                 }

   867                 break;

   868             }

   869         }

   870 

   871     CleanupStack::PopAndDestroy( cmName );

   872     }

   873 

   874 // --------------------------------------------------------------------------

   875 // CCmDlg::RenameConnectionMethodL    

   876 // --------------------------------------------------------------------------

   877 //

   878 void CCmDlg::RenameConnectionMethodL()

   879     {

   880     LOGGER_ENTERFN( "CCmDlg::RenameConnectionMethodL" );

   881 

   882     CCmPluginBase* cm = CurrentCML();

   883     if ( !cm )

   884         {

   885         return;

   886         }

   887 

   888     if ( cm->GetBoolAttributeL( ECmProtected ) )

   889         {

   890         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   891                                 TCmCommonUi::ECmErrorNote );

   892         return;

   893         }

   894 

   895     if ( CurrentCmInUseL() )

   896         {

   897         return;

   898         } 

   899            

   900     TBuf<KConnMethodNameMaxLength> buf;

   901     

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

   903     CleanupStack::PushL(cmName);

   904     buf.Copy(*cmName);

   905     

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

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

   908     cm->SetIntAttributeL( ECmNamingMethod, ENamingNotAccept );

   909 

   910     // Asks the new name

   911     TBool go = ETrue;

   912     TInt ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   913                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   914                                                 buf );

   915     

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

   917     while( ret && go )

   918         {

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

   920         // then ret == KErrArgument

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

   922 

   923         if( KErrArgument == err )

   924             {

   925             // Opens a info note

   926             HBufC* noteLine = StringLoader::LoadLC(

   927                     R_CMMANAGERUI_INFO_CM_ALREADY_IN_USE, buf );

   928 

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

   930 

   931             CleanupStack::PopAndDestroy( noteLine );

   932 

   933             // Asks the new name again

   934             ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   935                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   936                                                 buf );

   937             }

   938         else

   939             {

   940             // New name is unique loop can stop

   941             go = EFalse;

   942             }    

   943         }

   944 

   945     // Sets back the original naming method

   946     cm->SetIntAttributeL( ECmNamingMethod, savedNM );

   947 

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

   949     if( ret )

   950         {

   951         cm->UpdateL();

   952         

   953         HandleListboxDataChangeL();

   954         }

   955    

   956     CleanupStack::PopAndDestroy( cmName );

   957     }

   958 

   959 // --------------------------------------------------------------------------

   960 // CCmDlg::PrioritiseConnectionMethodL    

   961 // --------------------------------------------------------------------------

   962 //

   963 void CCmDlg::PrioritiseConnectionMethodL()

   964     {

   965     LOGGER_ENTERFN( "CCmDlg::PrioritiseConnectionMethodL" );

   966     

   967     ButtonGroupContainer().SetCommandSetL( R_SOFTKEYS_PRIO_OK_CANCEL__OK );

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

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

   970     ButtonGroupContainer().DrawNow();

   971     iPrioritising = ETrue;

   972     iCmToPrioritise = iListbox->CurrentItemIndex();

   973     }

   974 

   975 // --------------------------------------------------------------------------

   976 // CCmDlg::AddConnectionMethodL    

   977 // --------------------------------------------------------------------------

   978 //

   979 void CCmDlg::AddConnectionMethodL()

   980     {

   981     LOGGER_ENTERFN( "CCmDlg::AddConnectionMethodL" );

   982 

   983     // Check first if parent destination is protected

   984     if ( iCmDestinationImpl && 

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

   986         {

   987         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   988                                 TCmCommonUi::ECmErrorNote );

   989         return;

   990         }

   991 

   992     // Opens a Connection method creation wizard

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

   994 

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

   996 

   997     TInt ret( KErrNone );

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

   999     if ( err )

  1000         {

  1001         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1002                 TCmCommonUi::ECmErrorNote );

  1003         ret = KErrCancel;

  1004         }

  1005     delete iCmWizard;

  1006     iCmWizard = NULL;

  1007 

  1008 

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

  1010     // should be called here                

  1011     if( iEscapeArrived )

  1012         {

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

  1014         }

  1015     

  1016     if( ret != KErrCancel )

  1017         {

  1018         iHighlight = ret;

  1019 

  1020 

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

  1022         if ( CMCount() == 1 )

  1023             {

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

  1025             ButtonGroupContainer().SetCommandL( ECmManagerUiCmdCmEdit, 

  1026                                                     *text );

  1027             CleanupStack::PopAndDestroy( text );

  1028             }

  1029         

  1030         //HandleListboxDataChangeL();

  1031         TRAP( err, HandleListboxDataChangeL() );

  1032         if ( err )

  1033             {

  1034             TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1035                     TCmCommonUi::ECmErrorNote );

  1036             return;

  1037             }

  1038         iListbox->HandleItemAdditionL();

  1039     

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

  1041             {

  1042             //first item cannot be deleted

  1043             iListbox->ScrollToMakeItemVisible( 

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

  1045             iListbox->SetCurrentItemIndex( iHighlight );

  1046             }

  1047         }

  1048     }

  1049 

  1050 // --------------------------------------------------------------------------

  1051 // CCmDlg::CopyConnectionMethodL    

  1052 // --------------------------------------------------------------------------

  1053 //

  1054 void CCmDlg::CopyConnectionMethodL()

  1055     {

  1056     LOGGER_ENTERFN( "CCmDlg::CopyConnectionMethodL" );

  1057 

  1058     CCmPluginBase* cm = CurrentCML();

  1059     if ( !cm )

  1060         {

  1061         return;

  1062         }

  1063     

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

  1065         ( iCmDestinationImpl && 

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

  1067         {

  1068         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1069                                 TCmCommonUi::ECmErrorNote );

  1070         return;

  1071         }

  1072 

  1073     TUint32 destId( 0 );

  1074     

  1075     // build an array of possible parent destinations

  1076     TInt destCount=0;

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

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

  1079         {

  1080         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_DESTINATION,

  1081                                 TCmCommonUi::ECmErrorNote );

  1082         return;

  1083         }

  1084         

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

  1086     CleanupClosePushL( destArray );

  1087     

  1088     iCmManager->AllDestinationsL( destArray );

  1089     

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

  1091     if ( iCmDestinationImpl ) 

  1092         {

  1093         destId = iCmDestinationImpl->Id();

  1094         

  1095         TInt index = destArray.Find( destId );

  1096         if ( index != KErrNotFound )

  1097             {

  1098             destArray.Remove( index );

  1099             }

  1100         }

  1101     

  1102     

  1103     // now filter the destinations

  1104     CurrentCML()->FilterPossibleParentsL( destArray );

  1105 

  1106     // check if there are any remaining destinations

  1107     if ( !destArray.Count() )

  1108         {

  1109         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_VPN_STACKING,

  1110                                 TCmCommonUi::ECmErrorNote );        

  1111         CleanupStack::PopAndDestroy( &destArray );

  1112         return;

  1113         }

  1114 

  1115     // create a copy of the current connection method

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

  1117     CleanupStack::PushL( cmCopy );

  1118 

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

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

  1121                                                               *iCmManager, 

  1122                                                               &destArray );

  1123 

  1124     if ( dlg->ExecuteLD( R_CMMANAGER_LIST_QUERY_WITH_MSGBOX ) )

  1125         {

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

  1127         CleanupStack::PushL( dest ); 

  1128         if ( iCmDestinationImpl )

  1129             {

  1130             // store it in commsdat

  1131             cmCopy->UpdateL();

  1132             dest->AddConnectionMethodL( *cmCopy );

  1133             }

  1134         else

  1135             {