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     ShowPopupNoteL();        

   192     }

   193     

   194 // --------------------------------------------------------------------------

   195 // CCmDlg::DynInitMenuPaneL

   196 // --------------------------------------------------------------------------

   197 //

   198 void CCmDlg::DynInitMenuPaneL( TInt aResourceId,

   199                                         CEikMenuPane* aMenuPane )

   200     {

   201     CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane );        

   202     if ( aResourceId == R_CM_MENU )

   203         {

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

   205             {

   206             aMenuPane->DeleteMenuItem( EAknCmdHelp );		    

   207             }

   208         // Menu items

   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             hideRename  = ETrue;

   222             hideDelete  = ETrue;

   223             hideCopy = ETrue;

   224             hideMove = ETrue; 

   225             }

   226         // Embedded destinations can be deleted but not edited

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

   228             {

   229             hideRename  = ETrue;

   230             }

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

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

   233             {

   234             hidePrioritise = ETrue;

   235             }            

   236         // virtual CMs pointing to destinations

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

   238             {

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

   240                 {

   241                 hidePrioritise = ETrue;

   242                 }

   243             }

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

   245         RArray<TUint32> destinations( KCmArrayMediumGranularity );

   246         CleanupClosePushL( destinations );

   247         iCmManager->AllDestinationsL( destinations );

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

   249             {            

   250             CCmDestinationImpl* dest = 

   251                                     iCmManager->DestinationL( destinations[i] );

   252             CleanupStack::PushL( dest );

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

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

   255                 {

   256                 // iCmDestinationImpl is null in Uncat dlg - ignore

   257                 // Don't count the current destination

   258                 if ( !iCmDestinationImpl || 

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

   260                     {

   261                     hideCopy = EFalse;

   262                     hideMove = EFalse;

   263                     CleanupStack::PopAndDestroy( dest );

   264                     break;

   265                     }

   266                 }

   267             CleanupStack::PopAndDestroy( dest );                

   268             }

   269         CleanupStack::PopAndDestroy( &destinations );    

   270         

   271         // Show or hide menu items

   272         if ( aResourceId == R_CM_MENU )

   273             {            

   274             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmAdd,     hideAdd );

   275             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmRename,  hideRename );            

   276             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmDelete,  hideDelete );    

   277             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmPrioritise, hidePrioritise );

   278             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmMoveToOtherDestination, hideMove );

   279             aMenuPane->SetItemDimmed( ECmManagerUiCmdCmCopyToOtherDestination, hideCopy ); 

   280             }

   281         }   

   282     }

   283     

   284 // ---------------------------------------------------------------------------

   285 // CCmDlg::InitTextsL

   286 // called before the dialog is shown

   287 // to initialize localized textual data

   288 // ---------------------------------------------------------------------------

   289 //

   290 void CCmDlg::InitTextsL()

   291     {

   292     // set pane text if neccessary...

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

   294     HBufC* primary = 

   295               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_PRIMARY );

   296     HBufC* secondary = 

   297               iEikonEnv->AllocReadResourceLC( R_CMMANAGERUI_EMPTY_METHOD_VIEW_SECONDARY );

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

   299     CleanupStack::PushL(items);

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

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

   302     HBufC* emptyText = 

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

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

   305     CleanupStack::PopAndDestroy( emptyText );

   306     CleanupStack::PopAndDestroy( items );

   307     CleanupStack::PopAndDestroy( secondary );

   308     CleanupStack::PopAndDestroy( primary );

   309 

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

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

   312                                           TUid::Uid( EEikStatusPaneUidTitle ) );

   313 

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

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

   316     iTitlePane->SetTextL( *name );

   317     CleanupStack::PopAndDestroy( name );

   318 

   319     iNaviPane = ( CAknNavigationControlContainer* ) 

   320                     iStatusPane->ControlL( 

   321                             TUid::Uid( EEikStatusPaneUidNavi ) );

   322     iNaviDecorator = iNaviPane->CreateNavigationLabelL( KNullDesC );

   323     iNaviPane->PushL( *iNaviDecorator );

   324     }

   325 

   326 // ---------------------------------------------------------------------------

   327 // CCmDlg::SetNoOfCMsL

   328 // ---------------------------------------------------------------------------

   329 //

   330 

   331 void CCmDlg::SetNoOfCMsL(TInt aCount)

   332     {

   333     if ( iNaviDecorator )

   334         {

   335         if ( iNaviDecorator->ControlType() == 

   336              CAknNavigationDecorator::ENaviLabel)

   337             {

   338             CAknNaviLabel* naviLabel = 

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

   340             if (aCount)

   341                 {

   342                 HBufC* title = NULL;

   343                 

   344                 if (aCount == 1)

   345                     {

   346                     title = StringLoader::LoadLC( 

   347                                            R_CMMANAGERUI_NAVI_ONE_CONN_METHOD );

   348                     }

   349                 else

   350                     {

   351                     title = StringLoader::LoadLC( 

   352                                            R_CMMANAGERUI_NAVI_MANY_CONN_METHODS, 

   353                                            aCount );

   354                     }

   355                     

   356                 naviLabel->SetTextL(*title);

   357                   CleanupStack::PopAndDestroy( title );

   358                 }

   359             else

   360                 {

   361                 naviLabel->SetTextL(KNullDesC);

   362                 }

   363                 

   364             iNaviPane->PushL( *iNaviDecorator );

   365             }

   366         }

   367       

   368     }

   369 

   370 //----------------------------------------------------------

   371 // CCmDlg::CreateCustomControlL

   372 //----------------------------------------------------------

   373 //

   374 SEikControlInfo CCmDlg::CreateCustomControlL( TInt aControlType )

   375     {

   376     SEikControlInfo controlInfo;

   377     controlInfo.iTrailerTextId = 0;

   378     controlInfo.iFlags = 0;

   379     if ( aControlType == KCmListboxType )

   380         {

   381         controlInfo.iControl = new ( ELeave ) CCmListbox;

   382         }

   383     else

   384         {

   385         controlInfo.iControl = NULL;

   386         }

   387     return controlInfo;

   388     }

   389 

   390 // ---------------------------------------------------------------------------

   391 // CCmDlg::OkToExitL

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

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

   394 // ---------------------------------------------------------------------------

   395 //

   396 TBool CCmDlg::OkToExitL( TInt aButtonId )

   397     {

   398     LOGGER_ENTERFN( "CCmDlg::OkToExitL" );

   399 

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

   401     // view to handle

   402     // Dialog should not exit

   403     TBool retVal( EFalse );

   404     

   405     switch ( aButtonId )

   406         {

   407         case EAknSoftkeyOk:

   408         case ECmManagerUiCmdCmEdit:

   409             {

   410             if ( !iProcessing )

   411                 {

   412                 if ( CMCount() )

   413                     {

   414                     iProcessing = ETrue;

   415                     ProcessCommandL( aButtonId );

   416                     iProcessing = EFalse;

   417                     }

   418                 else

   419                     {

   420                     iProcessing = ETrue;

   421                     AddConnectionMethodL();

   422                     iProcessing = EFalse;

   423                     }

   424                 }

   425             break;

   426             }

   427         case EAknSoftkeyClear:

   428             {

   429             ProcessCommandL( aButtonId );

   430             break;

   431             }

   432         case ECmManagerUiCmdCmPrioOk:

   433             {

   434             if ( iPrioritising )

   435                 {

   436                 FinishPriorizingL( ETrue );

   437                 }

   438                 

   439             break;

   440             }               

   441        case ECmManagerUiCmdCmPrioCancel:            

   442             {

   443             if ( !MenuShowing() )            

   444                 {

   445                 if ( iPrioritising )

   446                     {

   447                     FinishPriorizingL( EFalse );

   448                     }

   449                 }            

   450             break;

   451             }           

   452         case ECmManagerUiCmdCmUserExit:

   453             {

   454             iCmManager->WatcherUnRegister();

   455                         

   456             iExitReason = KDialogUserExit;

   457             break;

   458             }

   459         case EAknSoftkeyBack:

   460             {

   461             iCmManager->WatcherUnRegister();

   462             

   463             if ( !iProcessing )

   464                 {

   465                 *iSelected = 0;

   466                 TryExitL( iExitReason );

   467                 }

   468             else

   469                 {

   470                 iBackduringProcessing = ETrue;

   471                 }

   472             break;

   473             }

   474         default:

   475             {

   476             if ( !iProcessing )

   477                 {

   478                 if ( aButtonId == EAknSoftkeyOptions )

   479                     {

   480                     DisplayMenuL();

   481                     }

   482                 else

   483                     {

   484                     retVal = ETrue;

   485                     }

   486                 }

   487             if ( iProcessing )

   488                 {

   489                 iExitduringProcessing = ETrue;

   490                 if( aButtonId == KDialogUserExit )

   491                     {

   492                     retVal = ETrue;

   493                     } 

   494                 }

   495             break;

   496             }

   497         }

   498     return retVal;

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CCmDlg::HandleListBoxEventL

   503 // ---------------------------------------------------------------------------

   504 //

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

   506                                   TListBoxEvent aEventType )

   507     {

   508     LOGGER_ENTERFN( "CCmDlg::HandleListBoxEventL" );

   509 

   510     switch ( aEventType )

   511         {

   512         case EEventEnterKeyPressed:

   513             {

   514             if ( iPrioritising )

   515                 {

   516                 FinishPriorizingL( ETrue );

   517                 }

   518             else

   519                 {

   520                 if ( !iProcessing )

   521                     {

   522                     delete iCmdExec;

   523                     iCmdExec = NULL;

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

   525                     iCmdExec->Execute();

   526                     }

   527                 }           

   528             break;            

   529             }

   530         case EEventItemSingleClicked:

   531             {

   532             if ( !iProcessing )

   533                 {

   534                 delete iCmdExec;

   535                 iCmdExec = NULL;

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

   537                 iCmdExec->Execute();

   538                 }

   539             break;

   540             }

   541         case EEventEditingStarted:

   542             {

   543             break;

   544             }

   545         case EEventEditingStopped:

   546             {

   547             break;

   548             }

   549         default:

   550             {

   551             break;

   552             };

   553         };

   554     }

   555        

   556     

   557 // ---------------------------------------------------------------------------

   558 // CCmDlg::ProcessCommandL

   559 // ---------------------------------------------------------------------------

   560 //

   561 void CCmDlg::ProcessCommandL( TInt aCommandId )

   562     {

   563     LOGGER_ENTERFN( "CCmDlg::ProcessCommandL" );

   564 

   565     if ( MenuShowing() )

   566         {

   567         HideMenu();

   568         }

   569 

   570     switch ( aCommandId )

   571         {        

   572         // Connection Method Modification Commands

   573         case ECmManagerUiCmdCmAdd:

   574             {

   575             if ( !iProcessing )

   576                 {

   577                 iProcessing = ETrue;

   578                 TRAPD( err, AddConnectionMethodL() );

   579                 // Memory full

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

   581                     {

   582                     iProcessing = EFalse;

   583                     return;

   584                     }

   585                 iProcessing = EFalse;

   586 

   587                 if ( iBackduringProcessing )

   588                     {

   589                     iBackduringProcessing = EFalse;

   590                     TryExitL( KDialogUserBack );

   591                     }

   592                 }

   593             break;

   594             }

   595 

   596         case ECmManagerUiCmdCmRename:            

   597             {

   598             RenameConnectionMethodL();

   599             break;

   600             }

   601             

   602         case EAknSoftkeyClear:

   603         case ECmManagerUiCmdCmDelete:            

   604             {

   605             if ( iPrioritising )

   606                 {

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

   608                 break;

   609                 }

   610             DeleteCurrentCmL();         

   611             break;

   612             }

   613             

   614         case ECmManagerUiCmdCmPrioritise:            

   615             {

   616             PrioritiseConnectionMethodL();

   617             break;

   618             }

   619             

   620         case ECmManagerUiCmdCmCopyToOtherDestination:            

   621             {

   622             CopyConnectionMethodL();            

   623             break;

   624             }

   625             

   626         case ECmManagerUiCmdCmMoveToOtherDestination:            

   627             {            

   628             MoveConnectionMethodL();

   629             break;

   630             }

   631             

   632         case EAknSoftkeyOk:

   633         case ECmManagerUiCmdCmEdit:

   634             {

   635             EditConnectionMethodL();

   636             break;

   637             }   

   638 

   639         // Button Selection commands

   640         case EAknSoftkeyOptions:

   641             {

   642             DisplayMenuL();

   643             break;

   644             }

   645             

   646         case ECmManagerUiCmdCmUserExit:

   647             {

   648             iExitReason = KDialogUserExit;

   649             }

   650             

   651         case EAknSoftkeyBack:

   652             {

   653             if (!iProcessing)

   654                 {

   655                 *iSelected = 0;

   656                 TryExitL( iExitReason );

   657                 }

   658             break;

   659             }

   660         case EAknCmdHelp:

   661             {

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

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

   664             }

   665             break;

   666 

   667         default:

   668             {

   669             break;

   670             }

   671         }

   672     }

   673 

   674 // ---------------------------------------------------------------------------

   675 // CCmDlg::DeleteCurrentCmL

   676 // ---------------------------------------------------------------------------

   677 //

   678 void CCmDlg::DeleteCurrentCmL( )

   679     {

   680     LOGGER_ENTERFN( "CCmDlg::DeleteCurrentCmL" );

   681 

   682     TCmDefConnValue oldConn;

   683     if (iCmManager->IsDefConnSupported())

   684         {

   685         iCmManager->ReadDefConnL( oldConn );

   686         }

   687     CCmPluginBase* cm = CurrentCML();

   688     if ( !cm )

   689     	{

   690     	return;

   691     	}

   692 

   693     if ( cm->GetBoolAttributeL( ECmProtected ) )

   694         {

   695         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   696                                 TCmCommonUi::ECmErrorNote );

   697                                 

   698         return;

   699         }

   700    

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

   702         {

   703         TCmCommonUi::ShowNoteL( 

   704                             R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   705                             TCmCommonUi::ECmErrorNote );

   706         

   707         return;

   708         }

   709    

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

   711         {

   712         TCmCommonUi::ShowNoteL( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   713                                 TCmCommonUi::ECmErrorNote );

   714         

   715         return;

   716         }

   717 

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

   719     // by a VPN

   720     if ( iCmDestinationImpl &&

   721          iCmDestinationImpl->ConnectionMethodCount() == 1 )

   722         {

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

   724 

   725         // for each IAP in CM manager

   726         //   1. check if it is virtual

   727         //      if not => goto 1.

   728         //      if yes:

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

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

   731         //         if not: carryOn = ETrue

   732 

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

   734                                                     iCmManager->AllIapsL();

   735         

   736         CleanupStack::PushL( iaps );

   737         

   738         TBool carryOn = ETrue;

   739         TUint32 destId = iCmDestinationImpl->Id();

   740 

   741         // for each IAP in CM manager

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

   743             {

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

   745             TUint32 bearerType = 0;

   746             

   747             TRAP_IGNORE( bearerType = 

   748                              iCmManager->BearerTypeFromIapRecordL( rec ) );

   749             if ( !bearerType )

   750                 {

   751                 continue;

   752                 }

   753                 

   754             // check if it is virtual

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

   756                 {

   757                 // check if it links to the current destination

   758                 CCmPluginBase* plugin = NULL;            

   759                 TRAP_IGNORE( plugin = iCmManager->GetConnectionMethodL( 

   760                                                            rec->RecordId() ) );

   761 

   762                 if ( !plugin )

   763                     {

   764                     continue;

   765                     }

   766                 

   767                 if ( plugin->IsLinkedToSnap( destId ) )

   768                     {

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

   770                     carryOn = EFalse;

   771                     }

   772 

   773                 delete plugin;

   774                 }

   775                     

   776             }

   777             

   778         CleanupStack::PopAndDestroy( iaps );

   779         

   780         if ( !carryOn )

   781             {

   782             TCmCommonUi::ShowNoteL( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   783                                 TCmCommonUi::ECmErrorNote );

   784             return;            

   785             }

   786         

   787         }

   788     

   789 

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

   791     TBool showCmDeleteQuery( ETrue );

   792     if ( cm->GetBoolAttributeL( ECmDestination ) )

   793         {

   794         if ( TCmCommonUi::ShowConfirmationQueryL(

   795                             R_CMMANAGERUI_QUEST_EMBEDDED_DEST_DELETE ) )

   796             {

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

   798             showCmDeleteQuery = EFalse;

   799             }

   800         else

   801             {

   802             return; // user cancelled delete request

   803             }

   804         }

   805 

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

   807     CleanupStack::PushL( cmName );

   808     

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

   810     // destintations

   811     // Protected CM's cannot be deleted either

   812     if ( !showCmDeleteQuery || iAlreadyConfirmedDelete ||

   813          TCmCommonUi::ShowConfirmationQueryL( 

   814                                     R_CMMANAGERUI_QUEST_CM_DELETE,

   815                                     *cmName ) )

   816         {

   817         TInt err = KErrNone;

   818         if ( iCmDestinationImpl )

   819             {

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

   821             }

   822         else

   823             {

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

   825             }

   826         

   827         switch ( err )

   828             {

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

   830                 {

   831                 TCmCommonUi::ShowNoteL

   832                     ( R_CMMANAGERUI_INFO_CM_IN_USE_CANNOT_DELETE,

   833                     TCmCommonUi::ECmErrorNote );

   834                 }

   835                 break;

   836                 

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

   838                 {

   839                 TCmCommonUi::ShowNoteL

   840                     ( R_QTN_NETW_CONSET_INFO_CANNOT_DELETE_VIRTUAL_REF,

   841                       TCmCommonUi::ECmErrorNote );

   842                 }

   843                 break;

   844                 

   845             case KErrNone:

   846                 {

   847                 if ( iCmDestinationImpl )

   848                     {

   849                     iCmDestinationImpl->UpdateL();

   850                     }

   851                 if (iCmManager->IsDefConnSupported())

   852                     {

   853                     iDestDlg->ShowDefaultConnectionNoteL( oldConn );

   854                     }

   855                 HandleListboxDataChangeL();

   856                 }

   857                 break;

   858 

   859             default:

   860                 {

   861                 }

   862                 break;

   863             }

   864         }

   865 

   866     CleanupStack::PopAndDestroy( cmName );

   867     }

   868 

   869 // --------------------------------------------------------------------------

   870 // CCmDlg::RenameConnectionMethodL    

   871 // --------------------------------------------------------------------------

   872 //

   873 void CCmDlg::RenameConnectionMethodL()

   874     {

   875     LOGGER_ENTERFN( "CCmDlg::RenameConnectionMethodL" );

   876 

   877     CCmPluginBase* cm = CurrentCML();

   878     if ( !cm )

   879         {

   880         return;

   881         }

   882 

   883     if ( cm->GetBoolAttributeL( ECmProtected ) )

   884         {

   885         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   886                                 TCmCommonUi::ECmErrorNote );

   887         return;

   888         }

   889 

   890     if ( CurrentCmInUseL() )

   891         {

   892         return;

   893         } 

   894            

   895     TBuf<KConnMethodNameMaxLength> buf;

   896     

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

   898     CleanupStack::PushL(cmName);

   899     buf.Copy(*cmName);

   900     

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

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

   903     cm->SetIntAttributeL( ECmNamingMethod, ENamingNotAccept );

   904 

   905     // Asks the new name

   906     TBool go = ETrue;

   907     TInt ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   908                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   909                                                 buf );

   910     

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

   912     while( ret && go )

   913         {

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

   915         // then ret == KErrArgument

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

   917 

   918         if( KErrArgument == err )

   919             {

   920             // Opens a info note

   921             HBufC* noteLine = StringLoader::LoadLC(

   922                     R_CMMANAGERUI_INFO_CM_ALREADY_IN_USE, buf );

   923 

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

   925 

   926             CleanupStack::PopAndDestroy( noteLine );

   927 

   928             // Asks the new name again

   929             ret = TCmCommonUi::ShowConfirmationQueryWithInputL(

   930                                                 R_CMMANAGERUI_PRMPT_CM_MAME,

   931                                                 buf );

   932             }

   933         else

   934             {

   935             // New name is unique loop can stop

   936             go = EFalse;

   937             }    

   938         }

   939 

   940     // Sets back the original naming method

   941     cm->SetIntAttributeL( ECmNamingMethod, savedNM );

   942 

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

   944     if( ret )

   945         {

   946         cm->UpdateL();

   947         

   948         HandleListboxDataChangeL();

   949         }

   950    

   951     CleanupStack::PopAndDestroy( cmName );

   952     }

   953 

   954 // --------------------------------------------------------------------------

   955 // CCmDlg::PrioritiseConnectionMethodL    

   956 // --------------------------------------------------------------------------

   957 //

   958 void CCmDlg::PrioritiseConnectionMethodL()

   959     {

   960     LOGGER_ENTERFN( "CCmDlg::PrioritiseConnectionMethodL" );

   961     

   962     ButtonGroupContainer().SetCommandSetL( R_SOFTKEYS_PRIO_OK_CANCEL__OK );

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

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

   965     ButtonGroupContainer().DrawNow();

   966     iPrioritising = ETrue;

   967     iCmToPrioritise = iListbox->CurrentItemIndex();

   968     }

   969 

   970 // --------------------------------------------------------------------------

   971 // CCmDlg::AddConnectionMethodL    

   972 // --------------------------------------------------------------------------

   973 //

   974 void CCmDlg::AddConnectionMethodL()

   975     {

   976     LOGGER_ENTERFN( "CCmDlg::AddConnectionMethodL" );

   977 

   978     // Check first if parent destination is protected

   979     if ( iCmDestinationImpl && 

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

   981         {

   982         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   983                                 TCmCommonUi::ECmErrorNote );

   984         return;

   985         }

   986 

   987     // Opens a Connection method creation wizard

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

   989 

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

   991 

   992     TInt ret( KErrNone );

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

   994     if ( err )

   995         {

   996         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

   997                 TCmCommonUi::ECmErrorNote );

   998         ret = KErrCancel;

   999         }

  1000     delete iCmWizard;

  1001     iCmWizard = NULL;

  1002 

  1003 

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

  1005     // should be called here                

  1006     if( iEscapeArrived )

  1007         {

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

  1009         }

  1010     

  1011     if( ret != KErrCancel )

  1012         {

  1013         iHighlight = ret;

  1014 

  1015 

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

  1017         if ( CMCount() == 1 )

  1018             {

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

  1020             ButtonGroupContainer().SetCommandL( ECmManagerUiCmdCmEdit, 

  1021                                                     *text );

  1022             CleanupStack::PopAndDestroy( text );

  1023             }

  1024         

  1025         //HandleListboxDataChangeL();

  1026         TRAP( err, HandleListboxDataChangeL() );

  1027         if ( err )

  1028             {

  1029             TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1030                     TCmCommonUi::ECmErrorNote );

  1031             return;

  1032             }

  1033         iListbox->HandleItemAdditionL();

  1034     

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

  1036             {

  1037             //first item cannot be deleted

  1038             iListbox->ScrollToMakeItemVisible( 

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

  1040             iListbox->SetCurrentItemIndexAndDraw( iHighlight );

  1041             }

  1042         }

  1043     }

  1044 

  1045 // --------------------------------------------------------------------------

  1046 // CCmDlg::CopyConnectionMethodL    

  1047 // --------------------------------------------------------------------------

  1048 //

  1049 void CCmDlg::CopyConnectionMethodL()

  1050     {

  1051     LOGGER_ENTERFN( "CCmDlg::CopyConnectionMethodL" );

  1052 

  1053     CCmPluginBase* cm = CurrentCML();

  1054     if ( !cm )

  1055         {

  1056         return;

  1057         }

  1058 

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

  1060         ( iCmDestinationImpl && 

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

  1062         {

  1063         TCmCommonUi::ShowNoteL( R_CMWIZARD_CANNOT_PERFORM_FOR_PROTECTED,

  1064                                 TCmCommonUi::ECmErrorNote );

  1065         return;

  1066         }

  1067 

  1068     TUint32 destId( 0 );

  1069     

  1070     // build an array of possible parent destinations

  1071     TInt destCount=0;

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

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

  1074         {

  1075         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_DESTINATION,

  1076                                 TCmCommonUi::ECmErrorNote );

  1077         return;

  1078         }

  1079         

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

  1081     CleanupClosePushL( destArray );

  1082     

  1083     iCmManager->AllDestinationsL( destArray );

  1084     

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

  1086     if ( iCmDestinationImpl ) 

  1087         {

  1088         destId = iCmDestinationImpl->Id();

  1089         

  1090         TInt index = destArray.Find( destId );

  1091         if ( index != KErrNotFound )

  1092             {

  1093             destArray.Remove( index );

  1094             }

  1095         }

  1096     

  1097     

  1098     // now filter the destinations

  1099     CurrentCML()->FilterPossibleParentsL( destArray );

  1100 

  1101     // check if there are any remaining destinations

  1102     if ( !destArray.Count() )

  1103         {

  1104         TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_VPN_STACKING,

  1105                                 TCmCommonUi::ECmErrorNote );        

  1106         CleanupStack::PopAndDestroy( &destArray );

  1107         return;

  1108         }

  1109     

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

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

  1112                                                               *iCmManager, 

  1113                                                               &destArray );

  1114 

  1115     if ( dlg->ExecuteLD( R_CMMANAGER_LIST_QUERY_WITH_MSGBOX ) )

  1116         {

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

  1118         CleanupStack::PushL( dest ); 

  1119         if ( iCmDestinationImpl )

  1120             {

  1121             // create a copy of the current connection method

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

  1123             CleanupStack::PushL( cmCopy );

  1124             // store it in commsdat

  1125             cmCopy->UpdateL();

  1126             dest->AddConnectionMethodL( *cmCopy );

  1127             

  1128             CleanupStack::PopAndDestroy( cmCopy );

  1129             }

  1130         else

  1131             {

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

  1133             }

  1134