diff -r 000000000000 -r 5a93021fdf25 apengine/apsettingshandlerui/src/ApSettingsDlg.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/apengine/apsettingshandlerui/src/ApSettingsDlg.cpp Thu Dec 17 08:55:21 2009 +0200 @@ -0,0 +1,6432 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Defines dialog for access point view/edit. +* +*/ + + +// INCLUDE FILES +#include "APSettingsHandlerUIVariant.hrh" + + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + + +#include "ApSettingsLookups.h" +#include "ApSettingsDlg.h" +#include "ApSettingsModel.h" +#include + +#include + +#include "ApSettingsHandlerUI.hrh" +#include "ApsettingshandleruiImpl.h" +#include "ApSettingsHandlerConsts.h" +#include + +#include "ApSettingsHandlerLogger.h" + +#include + +#include "ApNetSelPopupList.h" + +#include "AccessPointTextSettingPage.h" + + +#include + +#include "FeatureManagerWrapper.h" +#include "ApMultiLineDataQueryDialog.h" + +#include +#include +#include + +// CONSTANTS +// General Settings UID, Hardcoded +// const TUid KGeneralSettingsUid={0X100058EC}; +// const TInt KOptionalDefaultValue = 1; + + + +const TInt KIspCallAnalogue = 0; +const TInt KIspCallIsdn110 = 1; +const TInt KIspCallIsdn120 = 2; + +const TInt KBearerListGprs = 0; +const TInt KBearerListWLAN = 1; +const TInt KBearerListCSD = 2; +const TInt KBearerListHSCSD = 3; + + + +// They provide the indexes. +const TInt KBearerArrayCSD = 0; +const TInt KBearerArrayGPRS = 1; +const TInt KBearerArrayHSCSD = 2; +const TInt KBearerArrayWLAN = 3; + +const TInt KBoolMaxNumber = 1; + +_LIT( KEmptyText, "" ); +_LIT( KTxtListItemFormat, " \t%S\t\t%S" ); +_LIT( KTxtMenuListItemFormat, " \t%S\t\t" ); +_LIT( KTxtCompulsory, "\t*" ); + +_LIT( KTxtNumber, "%d" ); + + +_LIT( KKnownNameServer1, "fec0:000:0000:ffff::1" ); +_LIT( KKnownNameServer2, "fec0:000:0000:ffff::2" ); + + +const TInt KStaredPasswordLength = 4; + +const TUint32 KDefAdhocChannel = 7; + + +const TInt KItemIndex0 = 0; +const TInt KItemIndex1 = 1; +const TInt KItemIndex2 = 2; +const TInt KItemIndex3 = 3; + +// ================= MEMBER FUNCTIONS ======================= +// --------------------------------------------------------- +// CApSettingsDlg::ConstructAndRunLD +// Constructs the dialog and runs it. +// --------------------------------------------------------- +// +TInt CApSettingsDlg::ConstructAndRunLD( CApSettingsModel& aModel, + CApSettingsHandlerImpl& aHandler, + TUint32& aUid, + CApAccessPointItem* aItem ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ConstructAndRunLD") + + CleanupStack::PushL( this ); + + iFeatureManagerWrapper = CFeatureManagerWrapper::NewL(); + + iHelpSupported = FeatureManager::FeatureSupported( KFeatureIdHelp ); + +#ifdef __TEST_OOMDEBUG + RFs fs; + User::LeaveIfError( fs.Connect() ); + CleanupClosePushL( fs ); + TUint att; + if ( fs.Att( KTestFileName, att ) == KErrNone ) + { + iMemTestOn = ETrue; + } + else + { + iMemTestOn = EFalse; + } + CleanupStack::PopAndDestroy(); // fs, will also close it +#endif // __TEST_OOMDEBUG + + + iUid = &aUid; + + iDataModel = &aModel; + iHandler = &aHandler; + iVariant = iHandler->iExt->iVariant; + + + CApAccessPointItem* ap = CApAccessPointItem::NewLC(); + + iBearerItemArray = + new( ELeave )CArrayPtrFlat( KBearers ); + iBearerItemArray->ResetAndDestroy(); + for ( TInt i=0; iAppendL( NULL ); + } + TApBearerType ab = ap->BearerTypeL(); + iBearerItemArray->At( BearerToArrayIndexL( ab ) ) = ap; + // Now iApItem is part of array-> destructed member var, pop it. + CleanupStack::Pop( ap ); + + iApItem = ap; + + if ( !aItem ) + { + iDataModel->AccessPointDataL( *iUid, *iApItem ); + } + else + { + iApItem->CopyFromL( *aItem ); + } + iDataModel->ClearWEPAndWPASettings(); + + iOldApItem = CApAccessPointItem::NewLC(); + CleanupStack::Pop(); // member var + + iOldApItem->CopyFromL( *iApItem ); + + iOriginalBearerType = iApItem->BearerTypeL(); + + ConstructL( R_APSETTINGS_MENUBAR ); + + SetBearerTypeL( iApItem->BearerTypeL() ); + // ExecuteLD will PushL( this ), so we have to Pop it... + CleanupStack::Pop(); // this + + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ConstructAndRunLD") + return ExecuteLD( R_APSETTINGS_DIALOG ); + } + + + +// Destructor +CApSettingsDlg::~CApSettingsDlg() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::~CApSettingsDlg") + + delete iFeatureManagerWrapper; + + if ( iDataModel ) + {// Remove ourselves from observers... + iDataModel->Database()->RemoveObserver( this ); + } + + if ( iOldApItem ) + { + delete iOldApItem; + } + + if ( iNaviDecorator ) + { + delete iNaviDecorator; + } + + if ( iTitlePane ) + { + // set old text back, if we have it... + if ( iOldTitleText ) + { + if ( iExitReason != EShutDown ) + { + TRAP_IGNORE( iTitlePane->SetTextL( *iOldTitleText ) ); + } + delete iOldTitleText; + } + } + + if ( iBearerItemArray ) + { + iBearerItemArray->ResetAndDestroy(); + delete iBearerItemArray; + } + + if (iBackupApItem) + { + delete iBackupApItem; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::~CApSettingsDlg") + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent, +// TEventCode aType ) +// Handles key events +// --------------------------------------------------------- +// +TKeyResponse CApSettingsDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent, + TEventCode aType ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::OfferKeyEventL") + + TKeyResponse retval( EKeyWasNotConsumed ); + // Only interested in standard key events + if ( aType == EEventKey ) + { + // If a menu is showing offer key events to it. + if ( CAknDialog::MenuShowing() ) + { + retval = CAknDialog::OfferKeyEventL( aKeyEvent, aType ); + } + else + { + if ( iList ) + { + // as list IS consuming, must handle because it + // IS the SHUTDOWN... + // or, a view switch is shutting us down... + if ( aKeyEvent.iCode == EKeyEscape ) + { + ProcessCommandL( EEikCmdExit ); + retval = EKeyWasConsumed; + } + else + { + retval = iList->OfferKeyEventL( aKeyEvent, aType ); + if ( iSecSettingsExitReason ) + { + if ( iSecSettingsExitReason + & KApUiEventShutDownRequested ) + { + ProcessCommandL( EAknCmdExit ); + } + else + { + if ( iSecSettingsExitReason + & KApUiEventExitRequested ) + { + ProcessCommandL( EApSelCmdExit ); + } + } + } + } + } + else + { + if ( aKeyEvent.iCode == EKeyOK ) + { + ProcessCommandL( EApSelCmdChange ); + retval = EKeyWasConsumed; + } + } + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::OfferKeyEventL") + return retval; + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::NewL +// Two-phase dconstructor, second phase is ConstructAndRunLD +// --------------------------------------------------------- +// +CApSettingsDlg* CApSettingsDlg::NewL( TInt aIspFilter, + TInt aBearerFilter, + TInt aSortType, + TUint32& aEventStore, + TInt aReqIpvType + ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::NewL") + + CApSettingsDlg* db = + new ( ELeave )CApSettingsDlg( aIspFilter, + aBearerFilter, + aSortType, + aEventStore, + aReqIpvType + ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::NewL") + return db; + + } + + + + +// Constructor +CApSettingsDlg::CApSettingsDlg( TInt aIspFilter, TInt aBearerFilter, + TInt aSortType, TUint32& aEventStore, + TInt aReqIpvType ) +: +iLevel( 0 ), +iOldIndex( 0 ), +iOldTopIndex( 0 ), +iAdvIndex( 0 ), +iBearerType( EApBearerTypeAll ), +iIspFilter( aIspFilter ), +iBearerFilter( aBearerFilter ), +iSortType( aSortType ), +iEventStore( &aEventStore ), +iFieldCount( 0 ), +iAdvancedFieldCount( 0 ), +iExitReason( EExitNone ), +iReqIpvType( aReqIpvType ), +iL2Ipv4( ETrue ), +iSecSettingsExitReason(0) + { + iBackupApItem = NULL; + } + + +// --------------------------------------------------------- +// CApSettingsDlg::OkToExitL( TInt aButtonId) +// called by framework when the OK button is pressed +// --------------------------------------------------------- +// +TBool CApSettingsDlg::OkToExitL( TInt aButtonId ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::OkToExitL") + + // Translate the button presses into commands for the appui & current + // view to handle + TBool retval( EFalse ); + if ( aButtonId == EAknSoftkeyOptions ) + { + DisplayMenuL() ; + } + else + { + if ( (aButtonId == EApSelCmdChange) + || (aButtonId == EApSelCmdQuickChange)) + { + ProcessCommandL(aButtonId); + if ( iSecSettingsExitReason ) + { + if ( iSecSettingsExitReason + & KApUiEventShutDownRequested ) + { + ProcessCommandL( EAknCmdExit ); +// retval = ETrue; // exit the dialog + } + else + { + if ( iSecSettingsExitReason + & KApUiEventExitRequested ) + { + ProcessCommandL( EApSelCmdExit ); +// retval = ETrue; // exit the dialog + } + } + } + } + else + { + if ( aButtonId == EAknSoftkeyBack ) + { + if ( iLevel ) + { + TSaveAction cansave( EApNoAction ); + if ( iLevel == 2 ) + {// coming back from Ipv4 settings + // check if Wlan and has compulsory fields + if (iBearerType == EApBearerTypeWLAN) + { // WLAN + TApMember member; + cansave = CanSaveWlanCompulsoriesL( member ); + switch (cansave) + { + case EApCanSave: + { + // nothing to do in this case, simply go on. + iLevel --; + break; + } + case EApMustDelete: + { + // user said quit without save, + // restore from iBackupApItem + RestoreIpv4SettingsL(); + iLevel --; + break; + } + case EApShallGoBack: + { + // user wants to re-edit, do not come back... + // no change in iLevel + + // Set correct item to edit + switch ( member ) + { + case EApWlanIpNetMask: + case EApIspIPNetMask: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANSubnetMask ); + retval = EFalse; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApIspIPGateway: + case EApWlanIpGateway: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANDefaultGateway ); + retval = EFalse; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + {// otherwise, nothing to do... + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case EApNoAction: + default: + { + // this is not a valid case as it always one from + // the above 3, + // nothing to do, + iLevel --; + break; + } + } + } + else + { + iLevel--; + } + } + else + { + iLevel--; + } + HandleListboxDataChangeL( EFalse ); + if ( iOldIndex >=0 ) + { + if ( cansave != EApShallGoBack ) + { + iList->SetTopItemIndex( iOldTopIndex ); + iList->SetCurrentItemIndexAndDraw( iOldIndex ); + } + if ( *iEventStore & KApUiEventExitRequested ) + { + ProcessCommandL( EApSelCmdExit ); + } + } + } + else + { + if ( iExitReason == EShutDown ) + { + retval = ETrue; + } + else + { + if ( !(*iEventStore & KApUiEventShutDownRequested ) ) + { + retval = SaveDataL( ); + } + else + { + retval = ETrue; + } + } + } + } + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::OkToExitL") + return retval; + } + + + + +// --------------------------------------------------------- +// CApSettingsDlg::InitTextsL +// called before the dialog is shown +// to initialize localized textual data +// --------------------------------------------------------- +// +void CApSettingsDlg::InitTextsL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::InitTextsL") + + // set pane texts + // first get StatusPane + iStatusPane = iEikonEnv->AppUiFactory()->StatusPane(); + // then get TitlePane + iTitlePane = ( CAknTitlePane* ) iStatusPane->ControlL( + TUid::Uid( EEikStatusPaneUidTitle ) ); + // if not already stored, store it for restoring + if ( !iOldTitleText ) + { + iOldTitleText = iTitlePane->Text()->AllocL(); + } + // set new titlepane text + iTitlePane->SetTextL( iApItem->ConnectionName() ); + // if not already done, clear NaviPane with adding en empty one + if ( !iNaviDecorator ) + { + iNaviPane = ( CAknNavigationControlContainer* ) + iStatusPane->ControlL( + TUid::Uid( EEikStatusPaneUidNavi ) ); + iNaviDecorator = iNaviPane->CreateNavigationLabelL( KEmpty ); + iNaviPane->PushL( *iNaviDecorator ); + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::InitTextsL") + } + + + + +// --------------------------------------------------------- +// CApSettingsDlg::DynInitMenuPaneL +// --------------------------------------------------------- +// +void CApSettingsDlg::DynInitMenuPaneL +( TInt aResourceId, CEikMenuPane* aMenuPane ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::DynInitMenuPaneL") + + CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane ); + if ( aResourceId == R_APSETTINGS_MENU ) + { + if ( iLevel ) + { + // Disallow Advanced settings item if already in advanced + // or in SMS. + aMenuPane->DeleteMenuItem( EApSelCmdAdvanced ); + } + if ( !iHelpSupported ) + { + aMenuPane->DeleteMenuItem( EAknCmdHelp ); + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::DynInitMenuPaneL") + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::HandleListboxDataChangeL +// called before the dialog is shown to initialize listbox data +// --------------------------------------------------------- +// +void CApSettingsDlg::HandleListboxDataChangeL( TBool aReRead ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListboxDataChangeL") + + if ( aReRead && ( *iUid != KApNoneUID ) ) + { // reload the whole ApItem ! + // if it does not yet exists, no need to do so... + iDataModel->AccessPointDataL( *iUid, *iApItem ); + iDataModel->ClearWEPAndWPASettings(); + } + + iBearerType = iApItem->BearerTypeL(); + + // fill up our new list with data + CDesCArrayFlat* ItemArray = new ( ELeave ) CDesCArrayFlat( 4 ); + CleanupStack::PushL( ItemArray ); + switch ( iLevel ) + { + case 0: + { + FillListWithDataL( *ItemArray, *iField, iFieldCount, + iTitles, iCompulsory ); + break; + } + case 1: + { + FillListWithDataL( *ItemArray, *iFieldAdvanced, + iAdvancedFieldCount, iTitlesAdvanced, + iCompulsoryAdvanced ); + break; + } + case 2: + { + FillListWithDataL( *ItemArray, *iFieldL2, iFieldCountL2, + iTitlesL2, iCompulsoryL2 ); + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + + // if not already stored, store it for restoring + if ( !iOldTitleText ) + { + iOldTitleText = iTitlePane->Text()->AllocL(); + } + // set new title text + if ( iLevel == 2 ) + { + HBufC* value; + if ( iL2Ipv4 ) + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_IPV4_SETTINGS ); + } + else + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_IPV6_SETTINGS ); + } + iTitlePane->SetTextL( *value ); + CleanupStack::PopAndDestroy( value ); + } + else + { + iTitlePane->SetTextL( iApItem->ConnectionName() ); + } + + iList->Model()->SetItemTextArray( ItemArray ); + // now it is owned by the LB, so pop it + CleanupStack::Pop(); // do not destroy ! + iItemArray = ItemArray; + + iList->HandleItemAdditionL(); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListboxDataChangeL") + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::SetTextOverrides +// --------------------------------------------------------- +// +void CApSettingsDlg::SetTextOverrides( CTextOverrides* aOverrides ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::SetTextOverrides<->") + + __ASSERT_DEBUG( aOverrides, Panic( ENullPointer ) ); + iTextOverrides = aOverrides; + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::HandleApDbEventL +// called by the active access point framework +// --------------------------------------------------------- +// +void CApSettingsDlg::HandleApDbEventL( TEvent anEvent ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleApDbEventL") + + switch ( anEvent ) + { + case EDbChanged: + { + HandleListboxDataChangeL( ETrue ); + break; + } + case EDbClosing: + { + break; + } + case EDbAvailable: + { + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleApDbEventL") + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::GetHelpContext() +// --------------------------------------------------------- +// +void CApSettingsDlg::GetHelpContext(TCoeHelpContext& aContext) const + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetHelpContext") + + aContext.iMajor = iHandler->iHelpMajor; + switch ( iBearerType ) + { + case EApBearerTypeCSD: + case EApBearerTypeHSCSD: + { + switch ( iLevel ) + { + case 2: + { + if ( iL2Ipv4 ) + { + aContext.iContext = KSET_HLP_AP_DATA_AS_IPV4; + } + else + { + aContext.iContext = KSET_HLP_AP_DATA_AS_IPV6; + } + break; + } + case 1: + { + aContext.iContext = KSET_HLP_AP_SETTING_DATA_AS; + break; + } + case 0: + default: + { + aContext.iContext = KSET_HLP_AP_SETTING_DATA; + break; + } + } + break; + } + case EApBearerTypeGPRS: + { + if ( iLevel ) + { + aContext.iContext = KSET_HLP_AP_SETTING_GPRS_AS; + } + else + { + aContext.iContext = KSET_HLP_AP_SETTING_GPRS; + } + break; + } + case EApBearerTypeWLAN: + { + switch ( iLevel ) + { + case 2: + { + if ( iL2Ipv4 ) + { + aContext.iContext = KSET_HLP_AP_WLAN_AS_IPV4; + } + else + { + aContext.iContext = KSET_HLP_AP_WLAN_AS_IPV6; + } + break; + } + case 1: + { + aContext.iContext = KSET_HLP_AP_SETTING_WLAN_AS; + break; + } + case 0: + { + aContext.iContext = KSET_HLP_AP_SETTING_WLAN; + break; + } + default: + { + break; + } + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetHelpContext") + } + + +// --------------------------------------------------------- +// CApSettingsDlg::PreLayoutDynInitL(); +// called by framework before dialog is shown +// --------------------------------------------------------- +// +void CApSettingsDlg::PreLayoutDynInitL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::PreLayoutDynInitL") + + InitTextsL(); + + iList = STATIC_CAST( CAknSettingStyleListBox*, + Control( KApSettingsListboxId ) ); + + iList->CreateScrollBarFrameL( ETrue ); + iList->ScrollBarFrame()->SetScrollBarVisibilityL + ( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto ); + HandleListboxDataChangeL( EFalse ); + iList->SetCurrentItemIndex( 0 ); + iList->SetListBoxObserver( this ); + + iDataModel->Database()->AddObserverL( this ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::PreLayoutDynInitL") + } + + + + +// From MEikCommandObserver +void CApSettingsDlg::ProcessCommandL( TInt aCommandId ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ProcessCommandL") + + if ( MenuShowing() ) + { + HideMenu(); + } + + switch ( aCommandId ) + { + case EApSelCmdQuickChange: + { + ChangeSettingsL( ETrue ); + break; + } + case EApSelCmdChange: + { + ChangeSettingsL( EFalse ); + break; + } + case EApSelCmdAdvanced: + { + if ( iLevel == 0 ) + { + iLevel ++; + iOldIndex = iList->CurrentItemIndex(); + iOldTopIndex = iList->TopItemIndex(); + iList->SetCurrentItemIndex( 0 ); + TRAPD( err, HandleListboxDataChangeL( EFalse ) ); + if ( err ) + { + iLevel--; + User::Leave( err ); + } + } + break; + } + case EAknCmdHelp: + { + if ( iHelpSupported ) + { + iDataModel->LaunchHelpL(); + } + break; + } +// case EAknSoftkeyBack: + case EApSelCmdExit: + { + iExitReason = EExit; + *iEventStore |= KApUiEventExitRequested; + TryExitL( EAknSoftkeyBack ); + break; + } + case EAknCmdExit: + case EEikCmdExit: + { + *iEventStore |= KApUiEventShutDownRequested; + iExitReason = EShutDown; + TryExitL( EAknSoftkeyBack ); + break; + } + default: + { + // silently ignore it + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ProcessCommandL") + } + + +// From MEikListBoxObserver +void CApSettingsDlg::HandleListBoxEventL( CEikListBox* /*aListBox*/, + TListBoxEvent aEventType ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListBoxEventL") + + switch ( aEventType ) + { + case EEventEnterKeyPressed: + // both handled in the same way for now... + case EEventItemDoubleClicked: + case EEventItemSingleClicked: + { + ChangeSettingsL( ETrue ); + break; + } + case EEventItemClicked: + { + break; + } + case EEventEditingStarted: + { + break; + } + case EEventEditingStopped: + { + break; + } + default: + { +// __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + }; + }; + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListBoxEventL") + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::FillListWithDataL +//---------------------------------------------------------- +// +void CApSettingsDlg::FillListWithDataL( CDesCArrayFlat& aItemArray, + const TApMember& arr, TInt aLength, + const TInt* aRes, + const TInt* aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::FillListWithDataL") + + TInt i; + TApMember* sgd = MUTABLE_CAST( TApMember*, &arr ); + for( i=0; iBearerTypeL() == EApBearerTypeGPRS ) + { + TUint32 tint; + iApItem->ReadUint( EApGprsPdpType, tint ); + if ( tint != EIPv6 ) + { + AddTextualListBoxItemL( aItemArray, *sgd, + *aRes, *aCompulsory ); + } + } + else + { // CSD + if ( iL2Ipv4 ) + { + AddTextualListBoxItemL( aItemArray, *sgd, + *aRes, *aCompulsory ); + } + } + break; + } + case EApWapCurrentBearer: + case EApWapSecurity: + case EApWapWspOption: + case EApIspPromptForLogin: + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + case EApIspBearerCallTypeIsdn: + case EApIspIfCallbackEnabled: + case EApIspIfCallbackType: + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + case EApIspUseLoginScript: + case EApIspBearerSpeed: + case EApGprsPdpType: + case EApIP6DNSAddrFromServer: + case EApWlanNetworkMode: + case EApWlanSecurityMode: + case EApWlanScanSSID: + { + AddOnOffListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); + break; + } + case EApWlanChannelId: + { + if ( IsAdhocChannelVisible() ) + { + AddOnOffListBoxItemL( aItemArray, *sgd, *aRes, + *aCompulsory ); + } + break; + } + case EApIpv4Settings: + case EApIpv6Settings: + { + AddMenuListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); + break; + } + case EApWlanSecuritySettings: + { + AddMenuListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + sgd++; + aRes++; + aCompulsory++; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillListWithDataL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::AddTextualListBoxItemL +//---------------------------------------------------------- +// +void CApSettingsDlg::AddTextualListBoxItemL( CDesCArrayFlat& aItemArray, + TApMember aMember, TInt aRes, + TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::AddTextualListBoxItemL") + + HBufC* sgd = CreateTextualListBoxItemL( aMember, aRes, aCompulsory ); + CleanupStack::PushL( sgd ); + aItemArray.AppendL( sgd->Des() ); + CleanupStack::PopAndDestroy( sgd ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddTextualListBoxItemL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::AddOnOffListBoxItem +//---------------------------------------------------------- +// +void CApSettingsDlg::AddOnOffListBoxItemL( CDesCArrayFlat& aItemArray, + TApMember aMember, TInt aRes, + TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::AddOnOffListBoxItemL") + + // Read up title text from resource + HBufC* sgd = CreateOnOffListBoxItemL( aMember, aRes, aCompulsory ); + CleanupStack::PushL( sgd ); + aItemArray.AppendL( sgd->Des() ); + CleanupStack::PopAndDestroy( sgd ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddOnOffListBoxItemL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::UpdateOnOffListBoxItemL +//---------------------------------------------------------- +// +void CApSettingsDlg::UpdateOnOffListBoxItemL( TApMember aMember, TInt aRes, + TInt aPos, TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateOnOffListBoxItemL") + + // Read up title text from resource + HBufC* sgd = CreateOnOffListBoxItemL( aMember, aRes, aCompulsory ); + CleanupStack::PushL( sgd ); + // first try to add, if Leaves, list will be untouched + iItemArray->InsertL( aPos, sgd->Des() ); + // if successful, previous item is scrolled up with one, + // so delete that one... + if ( ++aPos < iItemArray->MdcaCount() ) + { + iItemArray->Delete( aPos ); + } + CleanupStack::PopAndDestroy( sgd ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateOnOffListBoxItemL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::TextualListBoxItemL +//---------------------------------------------------------- +// +void CApSettingsDlg::UpdateTextualListBoxItemL( TApMember aMember, TInt aRes, + TInt aPos, TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateTextualListBoxItemL") + + HBufC* sgd = CreateTextualListBoxItemL( aMember, aRes, aCompulsory ); + CleanupStack::PushL( sgd ); + // first try to add, if Leaves, list will be untouched + iItemArray->InsertL( aPos, sgd->Des() ); + // if successful, previous item is scrolled up with one, + // so delete that one... + if ( ++aPos < iItemArray->MdcaCount() ) + { + iItemArray->Delete( aPos ); + } + CleanupStack::PopAndDestroy( sgd ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateTextualListBoxItemL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::CreateTextualListBoxItem +//---------------------------------------------------------- +// +HBufC* CApSettingsDlg::CreateTextualListBoxItemL( TApMember aMember, + TInt aRes, + TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::CreateTextualListBoxItemL") + + // both variables needed independently of the following + // conditions so I must declare them here... + HBufC16* value; + TBool Pushed( EFalse ); + if ( ( aMember == EApIspLoginScript ) || ( aMember == EApWapStartPage ) + || ( aMember == EApGprsAccessPointName ) + || ( aMember == EApProxyServerAddress ) ) + { + // allocates as much as needed... + value = iApItem->ReadConstLongTextL( aMember )->AllocLC(); + } + else + { + value = HBufC::NewLC( KModifiableTextLength ); + // handle different 'types' (8 bit or 16 bit) descriptors + // and bring them to common base (16 bit...) + if ( ( aMember == EApIspIfCallbackInfo ) + || ( aMember == EApIspInitString ) ) + { + HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); + TPtr8 ptr( tmpValue8->Des() ); + iApItem->ReadTextL( aMember, ptr ); + value->Des().Copy( *tmpValue8 ); + CleanupStack::PopAndDestroy(); // tmpValue8 + } + else + { + if ( aMember == EApProxyPortNumber ) + { + TUint32 tempint; + iApItem->ReadUint( aMember, tempint ); + TPtr ptr( value->Des() ); + ptr.Format( KTxtNumber, tempint ); + } + else + { + TPtr16 ptr( value->Des() ); + if ( ( aMember == EApIspIfAuthPass ) + || ( aMember == EApIspLoginPass ) ) + { + ptr.SetLength( KStaredPasswordLength ); + ptr.Fill( '*' ); + } + else + { + iApItem->ReadTextL( aMember, ptr ); + } + } + } + switch ( aMember ) + { + case EApIspIPAddr: + { + if ( ( value->Compare( KDynIpAddress ) == 0 ) + || ( value->Compare( KEmptyText ) == 0 ) ) + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_IP_ADDR_DYNAMIC ); + Pushed = ETrue; + } + break; + } + case EApIspIPNetMask: + case EApIspIPGateway: + case EApWlanIpNetMask: + case EApWlanIpGateway: + { + if ( ( value->Compare( KDynIpAddress ) == 0 ) + || ( value->Compare( KEmptyText ) == 0 ) ) + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_COMPULSORY ); + Pushed = ETrue; + } + break; + } + case EApGprsIPNameServer1: + case EApIspIPNameServer1: + case EApGprsIPNameServer2: + case EApIspIPNameServer2: + { + if ( ( value->Compare( KDynIpAddress ) == 0 ) + || ( value->Compare( KEmptyText ) == 0 ) ) + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_DNS_SERVER_AUTOMATIC ); + Pushed = ETrue; + } + break; + } + case EApIspDefaultTelNumber: + case EApWlanNetworkName: + { + if ( value->Compare( KEmptyText ) == 0 ) + { + value = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_AVKON_COMPULSORY ); + Pushed = ETrue; + } + break; + } + default: + { + break; + } + } + } + // Define a heap descriptor to hold all the item text + // HBufC is non-modifiable + HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); + + HBufC* value1 = ReplaceWhiteSpaceCharactersLC( *value ); + + if ( value1->CompareC( KEmpty ) == 0 ) + { // empty, get 'None' as value + HBufC* temp = NULL; + switch ( aMember ) + { + case EApWapStartPage: + { // get special None for homepage + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_SETT_HOME_PAGE_NONE ); + break; + } + case EApIspIfAuthName: + { // user name none + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_USER_NAME_NONE ); + break; + } + case EApProxyServerAddress: + { // proxy server address none + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_PROXY_SERVER_ADDR_NONE ); + break; + } + case EApIspIfCallbackInfo: + { // callback number none + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_CB_NUMBER_NONE ); + break; + } + case EApIspLoginScript: + { // login script none + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_LOGIN_SCRIPT_NONE ); + break; + } + case EApIspInitString: + { // modem init string none + temp = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_MODEM_INIT_NONE ); + break; + } + default: + { // get 'normal' None for others + temp = + iEikonEnv->AllocReadResourceLC( + R_APUI_SETT_VAL_FIELD_NONE ); + break; + } + } + CleanupStack::Pop(); // temp + CleanupStack::PopAndDestroy( value1 ); + CleanupStack::PushL( temp ); + value1 = temp; + } + + // Define a heap descriptor to hold all the item text + TInt length = title->Length() + value1->Length() + 10; + if ( aCompulsory ) + { + length += 3; + } + HBufC* itemText = HBufC::NewLC( length ); + + // handle exotic language number conversion here + TPtr t(title->Des()); + TPtr v(value1->Des()); + AknTextUtils::LanguageSpecificNumberConversion( t ); + AknTextUtils::LanguageSpecificNumberConversion( v ); + + // Define a modifiable pointer descriptor to be able to append text to the + // non-modifiable heap descriptor itemText + TPtr itemTextPtr = itemText->Des(); + itemTextPtr.Format( KTxtListItemFormat, title, value1 ); + if ( aCompulsory ) + { + itemTextPtr.Append( KTxtCompulsory ); + } + CleanupStack::Pop(); // itemtext, + if ( Pushed ) + { + // "Dynamic" text from resource if needed + CleanupStack::PopAndDestroy(); + } + // title, value, value1. !value is allocated with LC in both cases...! + CleanupStack::PopAndDestroy( 3 ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::CreateTextualListBoxItemL") + return itemText; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::CreateOnOffListBoxItemL +//---------------------------------------------------------- +// +HBufC* CApSettingsDlg::CreateOnOffListBoxItemL( TApMember aMember, TInt aRes, + TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::CreateOnOffListBoxItemL") + + // Read up title text from resource + HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); + + TUint32 aValueResourceID = 0; + TBool bvar; + + switch ( aMember ) + { + case EApIspBearerCallTypeIsdn: + {// Data call type "Analogue"/"ISDN" + TUint32 tempint; + iApItem->ReadUint( EApIspBearerCallTypeIsdn, tempint ); + switch ( tempint ) + { + case ECallTypeISDNv110: + { + aValueResourceID = R_APUI_VIEW_DATACALL_ISDN_110; + break; + } + case ECallTypeISDNv120: + { + aValueResourceID = R_APUI_VIEW_DATACALL_ISDN_120; + break; + } + case ECallTypeAnalogue: + default: + { + aValueResourceID = R_APUI_VIEW_DATACALL_ANALOLGUE; + break; + } + } + break; + } + case EApWapWspOption: + { // "Continuous"/"Temporary" + TUint32 tval; + iApItem->ReadUint( aMember, tval ); + if ( tval == EWapWspOptionConnectionOriented ) + { + aValueResourceID = R_APUI_VIEW_CONN_TYPE_CONTIN; + } + else + { + aValueResourceID = R_APUI_VIEW_CONN_TYPE_TEMP; + } + break; + } + case EApIspIfCallbackType: + { // "Use server number"/"Use other number" + TUint32 tval; + iApItem->ReadUint( aMember, tval ); + if ( tval == ECallbackActionMSCBCPAcceptServerSpecifiedNumber ) + { + aValueResourceID = R_APUI_VIEW_CB_USE_SERVER_NUMBER; + } + else + { + if ( tval == + ECallbackActionMSCBCPRequireClientSpecifiedNumber ) + { + aValueResourceID = R_APUI_VIEW_CB_USE_OTHER_NUMBER; + } + } + break; + } + case EApWapSecurity: + { // on/off + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_WTLS_SECURITY_ON; + } + else + { + aValueResourceID = R_APUI_VIEW_WTLS_SECURITY_OFF; + } + break; + } + case EApIspUseLoginScript: + { + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_USE_LOGINS_YES; + } + else + { + aValueResourceID = R_APUI_VIEW_USE_LOGINS_NO; + } + break; + } + + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + { + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_PPP_COMP_YES; + } + else + { + aValueResourceID = R_APUI_VIEW_PPP_COMP_NO; + } + break; + } + case EApIspPromptForLogin: + { + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_PROMPT_PASSWD_YES; + } + else + { + aValueResourceID = R_APUI_VIEW_PROMPT_PASSWD_NO; + } + break; + } + case EApIspIfCallbackEnabled: + { // yes/no + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_USE_CB_YES; + } + else + { + aValueResourceID = R_APUI_VIEW_USE_CB_NO; + } + break; + } + case EApWapCurrentBearer: + { // "Packet data"/"SMS"/"Data call" + if ( iBearerType == EApBearerTypeCSD ) + { + aValueResourceID = R_APUI_VIEW_BEARER_TYPE_CSD; + } + else + { + if ( iBearerType == EApBearerTypeHSCSD ) + { + aValueResourceID = R_APUI_VIEW_BEARER_TYPE_HSCSD; + } + else + { + if ( iBearerType == EApBearerTypeGPRS ) + { + aValueResourceID = R_APUI_VIEW_BEARER_TYPE_GPRS; + } + else + { + if ( IsWlanSupported() ) + { + if ( iBearerType == EApBearerTypeWLAN ) + { + aValueResourceID = + R_APUI_VIEW_BEARER_TYPE_WLAN; + } + else + { + User::Leave( KErrInvalidBearerType ); + } + } + else + { + User::Leave( KErrInvalidBearerType ); + } + } + } + } + break; + } + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + { // "Normal"/"Secure" + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_PASSWORD_AUTH_SECURE; + } + else + { + aValueResourceID = R_APUI_VIEW_PASSWORD_AUTH_NORMAL; + } + break; + } + case EApIspBearerSpeed: + { + TUint32 uvar; + iApItem->ReadUint( aMember, uvar ); + switch ( TApCallSpeed( uvar ) ) + { + case KSpeedAutobaud: + { + aValueResourceID = R_APUI_VIEW_SPEED_AUTODETECT; + break; + } + case KSpeed9600: + { + aValueResourceID = R_APUI_VIEW_SPEED_9600; + break; + } + case KSpeed14400: + { + aValueResourceID = R_APUI_VIEW_SPEED_14400; + break; + } + case KSpeed19200: + { + aValueResourceID = R_APUI_VIEW_SPEED_19200; + break; + } + case KSpeed28800: + { + aValueResourceID = R_APUI_VIEW_SPEED_28800; + break; + } + case KSpeed38400: + { + aValueResourceID = R_APUI_VIEW_SPEED_38400; + break; + } + case KSpeed43200: + { + aValueResourceID = R_APUI_VIEW_SPEED_43200; + break; + } + case KSpeed56000: + { + aValueResourceID = R_APUI_VIEW_SPEED_56000; + break; + } + default: + { + // auto-repair corrupted value + // use 9600 if previous data was not valid... + aValueResourceID = R_APUI_VIEW_SPEED_9600; + } + } + + break; + } + case EApGprsPdpType: + { + TUint32 uvar( 0 ); + iApItem->ReadUint( aMember, uvar ); + if ( uvar == EIPv6 ) + { + aValueResourceID = R_APUI_VIEW_PDP_TYPE_IPV6; + } + else + { + aValueResourceID = R_APUI_VIEW_PDP_TYPE_IPV4; + } + break; + } + case EApIP6DNSAddrFromServer: + { + // Change the 'magic numbers' + // Add the three possibilities here + iApItem->ReadBool( aMember, bvar ); + TInt stype = GetDomainNameServersTypeL(); + + switch ( stype ) + { + case 0: + { + aValueResourceID = + R_APUI_VIEW_NEW_AP_DNS_SERVERS_AUTOMATIC; + break; + } + case 1: + { + aValueResourceID = R_APUI_VIEW_SET_IP_WELL_KNOWN; + break; + } + case 2: + { + aValueResourceID = R_APUI_VIEW_SET_IP_USER_DEFINED; + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case EApWlanNetworkMode: + { + TUint32 netmode( 0 ); + iApItem->ReadUint( aMember, netmode ); + if ( netmode == EAdhoc ) + { + aValueResourceID = R_APUI_VIEW_WLAN_NETWORK_MODE_ADHOC; + } + else + { + aValueResourceID = R_APUI_VIEW_WLAN_NETWORK_MODE_INFRA; + } + break; + } + case EApWlanSecurityMode: + { + TUint32 secmode( 0 ); + iApItem->ReadUint( aMember, secmode ); + switch ( secmode ) + { + case EOpen: + { + aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN; + break; + } + case EWep: + { + aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_WEP; + break; + } + case E802_1x: + { + aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_802_1X; + break; + } + case EWpa: + case EWpa2: + { + aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_WPA; + break; + } + default: + { + aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN; + break; + } + } + + break; + } + case EApWlanScanSSID: + { // yes/no + iApItem->ReadBool( aMember, bvar ); + if ( bvar ) + { + aValueResourceID = R_APUI_VIEW_HIDDEN_NETWORK_YES; + } + else + { + aValueResourceID = R_APUI_VIEW_HIDDEN_NETWORK_NO; + } + break; + } + case EApWlanChannelId: + { // ad-hoc channel auto / user defined + TUint32 channel(0); + iApItem->ReadUint( aMember, channel ); + if ( channel ) + { + aValueResourceID = R_APUI_VIEW_AD_HOC_CHANNEL_USER_DEFINED; + } + else + { + aValueResourceID = R_APUI_VIEW_AD_HOC_CHANNEL_AUTO; + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + HBufC* value; + if ( aValueResourceID ) + { + // Read up value text from resource + value = iEikonEnv->AllocReadResourceLC( aValueResourceID ); + } + else + { + value = HBufC::NewLC( 0 ); + } + + + // Define a heap descriptor to hold all the item text + TInt length = title->Length() + value->Length() + 10 ; + if ( aCompulsory ) + { + length += 3; + } + + HBufC* itemText = HBufC::NewLC( length); + + // Define a modifiable pointer descriptor to be able to append text to the + // non-modifiable heap descriptor itemText + TPtr itemTextPtr = itemText->Des(); + itemTextPtr.Format( KTxtListItemFormat, title, value); + if ( aCompulsory ) + { + itemTextPtr.Append( KTxtCompulsory ); + } + + CleanupStack::Pop(); // itemText + CleanupStack::PopAndDestroy( 2 ); // value, title + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::CreateOnOffListBoxItemL") + return itemText; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::ChangeSettingsL +//---------------------------------------------------------- +// +void CApSettingsDlg::ChangeSettingsL( TBool aQuick ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeSettingsL") + +#ifdef __TEST_OOMDEBUG + if ( iMemTestOn ) + { + TInt leavecode( KErrNoMemory ); + + TInt ts( GetTestStateL() ); + + if ( ts == KEditingTest ) + { + TBuf<48> buf; + APSETUILOGGER_WRITE_BUF( _L("Starting Editing memtest") ); + + TUint32 rate( 0 ); + TUint32 retrycount( KOOMRetryCount ); + TUint32 retryoffset( KOOMRetryOffset ); + for ( + rate = 1; + ((rate < 50000) && (leavecode == KErrNoMemory)) || retrycount; + rate++ + ) + { + __UHEAP_SETFAIL( RHeap::EDeterministic, rate ); + TRAP( leavecode, DoChangeSettingsL( aQuick ) ); + __UHEAP_RESET; + if ( !leavecode ) + { + retrycount--; + rate += retryoffset; + } + } + User::LeaveIfError( leavecode ); + buf.Format( _L("\t Memtest finished, max. rate was: %d )"), rate ); + APSETUILOGGER_WRITE_BUF( buf ); + } + else + { + DoChangeSettingsL( aQuick ); + } + } + else + { + DoChangeSettingsL( aQuick ); + } +#else + DoChangeSettingsL( aQuick ); +#endif // __TEST_OOMDEBUG + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeSettingsL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::SetBearerTypeL +//---------------------------------------------------------- +// +void CApSettingsDlg::SetBearerTypeL( TApBearerType aBearer ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::SetBearerTypeL") + + iBearerType = aBearer; + + HandleListStructureChangeL(); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::SetBearerTypeL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::InvertSettingsL +//---------------------------------------------------------- +// +void CApSettingsDlg::InvertSettingsL( TApMember aDataMember ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::InvertSettingsL") + + switch ( aDataMember ) + { + case EApIspIfCallbackType: + { + TUint32 ctype( ECallbackActionMSCBCPRequireClientSpecifiedNumber ); + iApItem->ReadUint( EApIspIfCallbackType, ctype ); + if ( ctype == ECallbackActionMSCBCPRequireClientSpecifiedNumber ) + { + iApItem->WriteUint( EApIspIfCallbackType, + ECallbackActionMSCBCPAcceptServerSpecifiedNumber ); + } + else + { + iApItem->WriteUint( EApIspIfCallbackType, + ECallbackActionMSCBCPRequireClientSpecifiedNumber ); + } + break; + } + case EApGprsPdpType: + { + TUint32 ipnettype( 0 ); + iApItem->ReadUint( EApGprsPdpType, ipnettype ); + if ( ipnettype == EIPv6 ) + { + iApItem->WriteUint( EApGprsPdpType, EIPv4 ); + } + else + { + iApItem->WriteUint( EApGprsPdpType, EIPv6 ); + } + break; + } + case EApWlanNetworkMode: + { + TUint32 netmode( 0 ); + iApItem->ReadUint( EApWlanNetworkMode, netmode ); + if ( netmode == EAdhoc ) + { + iApItem->WriteUint( EApWlanNetworkMode, EInfra ); + } + else + { + iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); + LimitSecMode(); + } + break; + } + case EApWapWspOption: + { + TUint32 intvar; + if ( iApItem->ReadUint( aDataMember, intvar ) == KErrNone ) + { + if ( intvar == EWapWspOptionConnectionless ) + { + intvar = EWapWspOptionConnectionOriented; + } + else + { + intvar = EWapWspOptionConnectionless; + } + iApItem->WriteUint( aDataMember, intvar ); + } + break; + } + default: + { + TBool bvar; + if ( iApItem->ReadBool( aDataMember, bvar ) == KErrNone ) + { + bvar = !bvar; + iApItem->WriteBool( aDataMember, bvar ); + } + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::InvertSettingsL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::ShowPopupSettingPageL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::ShowPopupSettingPageL( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupSettingPageL") + + TInt currvalue( 0 ); + TBool retval( EFalse ); + TBool mustrepeat( EFalse ); + + CDesCArrayFlat* items = FillPopupSettingPageLC( aData, currvalue ); + + TInt attr_resid( 0 ); + GetResId( aData, attr_resid ); + + do + { + HBufC* titlebuf; + CAknRadioButtonSettingPage* dlg; + if ( attr_resid ) + { + titlebuf = iEikonEnv->AllocReadResourceLC( attr_resid ); + dlg = new ( ELeave )CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE, + currvalue, + items ); + // must push 'cause SetSettingTextL can leave... + CleanupStack::PushL( dlg ); + TPtrC ptr( titlebuf->Des() ); + dlg->SetSettingTextL( ptr ); + CleanupStack::Pop(); // dlg + } + else + { + dlg = new ( ELeave )CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE, + currvalue, + items ); + } + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + if( AskQueryIfWcdmaL( aData , currvalue) ) + { + UpdateFromPopupSettingPageL( aData, currvalue ); + retval = ETrue; + mustrepeat = EFalse; + } + else + { + mustrepeat = ETrue; + } + } + else + { + mustrepeat = EFalse; + } + if ( attr_resid ) + { + // titlebuf, text title readed from resource... + CleanupStack::PopAndDestroy(); + } + }while( mustrepeat ); + + + // items, will also delete all elements in the array! + CleanupStack::PopAndDestroy( items ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupSettingPageL") + return retval; + } + + + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::ShowPopupTextSettingPageL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::ShowPopupTextSettingPageL( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupTextSettingPageL") + + TBool retval( EFalse ); + + // must be prepared for the worst case... + TBuf textToChange; + + HBufC* aBuf1 = GetTextLC( aData ); + + HBufC* aBuf = ConvertPerNToDelimLC( aBuf1->Des() ); + + TPtr16 ptr( aBuf->Des() ); + textToChange.Append( ptr ); + + TInt page_resid( 0 ); + TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); + GetTextResId( aData, page_resid, TextSettingPageFlags ); + + + TBool isLatin ( aData == EApWapStartPage ); + + CAccessPointTextSettingPage* dlg = + new( ELeave )CAccessPointTextSettingPage( page_resid, textToChange, + TextSettingPageFlags, + isLatin ); + + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + switch ( aData ) + { + case EApWapStartPage: + case EApGprsAccessPointName: + case EApIspLoginScript: + case EApIspInitString: + case EApWapAccessPointName: + case EApIspLoginName: + case EApIspLoginPass: + case EApIspIfAuthName: + case EApIspIfAuthPass: + { + HBufC* tmp = ConvertDelimToPerNLC( textToChange ); + textToChange.Zero(); + textToChange.Append( tmp->Des() ); + CleanupStack::PopAndDestroy( tmp ); + break; + } + case EApProxyServerAddress: + { + textToChange.Trim(); + break; + } + default: + { // no need for conversion + break; + } + } + if ( ( aData == EApIspLoginScript ) || ( aData == EApWapStartPage ) + || ( aData == EApGprsAccessPointName ) + || ( aData == EApProxyServerAddress ) ) + { + iApItem->WriteLongTextL( aData, textToChange ); + } + else + { + if ( aData == EApProxyPortNumber ) + { + // first remove non-number chars + HBufC* num = StripNonNumberLC( textToChange ); + textToChange.Zero(); + textToChange.Append( num->Des() ); + CleanupStack::PopAndDestroy( num ); + // and now get real numberic value + TInt tempint; + TLex lex; + lex.Assign( textToChange ); + if ( lex.Val( tempint ) ) + { // this means some error, set it to 0 + tempint = 0; + } + iApItem->WriteUint( EApProxyPortNumber, tempint ); + } + else + { + if ( ( aData == EApIspInitString ) ) + { + // must be prepared for the worst case... + TBuf8 textToChange8; + textToChange8.Copy( textToChange ); + iApItem->WriteTextL( aData, textToChange8 ); + } + else + { + if ( aData == EApWapAccessPointName ) + { + iApItem->SetNamesL( textToChange ); + } + else + { + iApItem->WriteTextL( aData, textToChange ); + } + } + } + } + retval = ETrue; + } + *iEventStore |= KApUiEventEdited; + CleanupStack::PopAndDestroy( 2 ); // aBuf, aBuf1 + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupTextSettingPageL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetTextLC +//---------------------------------------------------------- +// +HBufC* CApSettingsDlg::GetTextLC( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetTextLC") + + HBufC* ret; + switch ( aData ) + { + case EApWapStartPage: + { // Long text !!! + if ( iApItem->ReadTextLengthL( aData ) ) + { + // allocates as much as needed... + ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); + } + else + { + ret = iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WAP_START_PAGE_DEFAULT ); + } + break; + } + case EApGprsAccessPointName: + { + // allocates as much as needed... + ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); + break; + } + case EApIspLoginScript: + { + // allocates as much as needed... + ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); + break; + } + case EApProxyServerAddress: + { + // allocates as much as needed... + ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); + break; + } + case EApWapGatewayAddress: + case EApIspIPAddr: + case EApIspIPNetMask: + case EApWlanIpNetMask: + case EApIspIPGateway: + case EApWlanIpGateway: + case EApGprsIPNameServer1: + case EApIspIPNameServer1: + case EApGprsIPNameServer2: + case EApIspIPNameServer2: + { + ret = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( ret->Des() ); + iApItem->ReadTextL( aData, ptr ); + if ( ptr.Compare( KEmptyText ) == 0 ) + { + *ret = KDynIpAddress; + } + break; + } + case EApIspInitString: + { + ret = HBufC::NewLC( KModifiableTextLength ); + HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); + TPtr8 ptr( tmpValue8->Des() ); + iApItem->ReadTextL( aData, ptr ); + ret->Des().Copy( ptr ); + CleanupStack::PopAndDestroy(); // tmpValue8 + break; + } + case EApProxyPortNumber: + { + TUint32 tempint; + iApItem->ReadUint( EApProxyPortNumber, tempint ); + ret = HBufC::NewLC( KMaxProxyPortNumberLength ); + TPtr itemTextPtr = ret->Des(); + itemTextPtr.Format( KTxtNumber, tempint ); + break; + } + default: + { + ret = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( ret->Des() ); + iApItem->ReadTextL( aData, ptr ); + break; + } + } + + switch ( aData ) + { + case EApWapStartPage: + case EApGprsAccessPointName: + case EApIspLoginScript: + case EApIspInitString: + case EApWapAccessPointName: + case EApIspLoginName: + case EApIspLoginPass: + case EApIspIfAuthName: + case EApIspIfAuthPass: + { + break; + } + default: + { + // nothing to do + break; + } + } + + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetTextLC") + return ret; + } + + +//---------------------------------------------------------- +// CApSettingsDlg::GetTextResId +//---------------------------------------------------------- +// +void CApSettingsDlg::GetTextResId( TApMember aData, TInt& apage, + TInt& aTextSettingPageFlags ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetTextResId") + + if ( ( aData != EApWapAccessPointName ) + && ( aData != EApIspDefaultTelNumber ) ) + { + aTextSettingPageFlags |= CAknTextSettingPage::EZeroLengthAllowed; + } + else + { + aTextSettingPageFlags &= (~CAknTextSettingPage::EZeroLengthAllowed); + } + + switch ( aData ) + { + case EApIspInitString: + { + apage = R_TEXT_SETTING_PAGE_MODEM_INIT_STRING; + break; + } + case EApWapAccessPointName: + { + apage = R_TEXT_SETTING_PAGE_CONN_NAME; + break; + } + case EApGprsAccessPointName: + { + apage = R_TEXT_SETTING_PAGE_GPRSAP_NAME; + break; + } + case EApIspLoginScript:// use EDWIN for script. + { + apage = R_TEXT_SETTING_PAGE_LOGIN_SCRIPT; + break; + } + case EApIspLoginName: + case EApIspIfAuthName: + { + apage = R_TEXT_SETTING_PAGE_LOGIN_NAME; + break; + } + case EApWapStartPage: + { + apage = R_TEXT_SETTING_PAGE_STARTING_PAGE; + break; + } + // use EDWINS as no such thing as PhoneNumber editor... + case EApIspDefaultTelNumber: + { + apage = R_TEXT_SETTING_PAGE_ACCESS_NUM; + break; + } + case EApIspIfCallbackInfo: + { + apage = R_TEXT_SETTING_PAGE_CB_NUM; + break; + } + case EApWapGatewayAddress: + { + apage = R_TEXT_SETTING_PAGE_GW_ADDR; + break; + } + case EApProxyServerAddress: + { + apage = R_TEXT_SETTING_PAGE_PROXY_SERVER_ADDR; + break; + } + case EApProxyPortNumber: + { + apage = R_TEXT_SETTING_PAGE_PROXY_PORT_NUMBER; + break; + } + case EApIspIPAddr: + { + apage = R_TEXT_SETTING_PAGE_ISPIP_ADDR; + break; + } + case EApIspIPNetMask: + case EApWlanIpNetMask: + { + apage = R_TEXT_SETTING_PAGE_ISP_NET_MASK; + break; + } + case EApIspIPGateway: + case EApWlanIpGateway: + { + apage = R_TEXT_SETTING_PAGE_ISP_GATEWAY; + break; + } + case EApGprsIPNameServer1: + case EApIspIPNameServer1: + { + apage = R_TEXT_SETTING_PAGE_NAME_SERV1; + break; + } + case EApGprsIPNameServer2: + case EApIspIPNameServer2: + { + apage = R_TEXT_SETTING_PAGE_NAME_SERV2; + break; + } + case EApIspLoginPass: + case EApIspIfAuthPass: + { // use EEikCtSecretEd + apage = R_TEXT_SETTING_PAGE_LOGIN_PASSWD; + break; + } + + case EApIspUseLoginScript: + {// use EDWIN: + apage = R_SETTING_APP_EDWIN_LOGIN_SCRIPT; + break; + } + case EApWlanNetworkName: + { + apage = R_TEXT_SETTING_PAGE_NETW_NAME; + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + apage = 0; + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetTextResId") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetResId +//---------------------------------------------------------- +// +void CApSettingsDlg::GetResId( TApMember aData, TInt& aattr ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetResId") + + // not text based ones: + switch ( aData ) + { + case EApWapCurrentBearer: + { + aattr = R_APUI_VIEW_BEARER_TYPE; + break; + } + case EApWapSecurity: + { + aattr = R_APUI_VIEW_WTLS_SECURITY; + break; + } + case EApWapWspOption: + { + aattr = R_APUI_VIEW_CONNECTION_TYPE; + break; + } + case EApIspPromptForLogin: + { + aattr = R_APUI_VIEW_PROMPT_PASSWORD; + break; + } + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + { + aattr = R_APUI_VIEW_PASSWORD_AUTH; + break; + } + case EApIspBearerCallTypeIsdn: // used for data call type + { + aattr = R_APUI_VIEW_DATA_CALL_TYPE; + break; + } + case EApIspBearerSpeed: + { + aattr = R_APUI_VIEW_MAX_CONN_SPEED; + break; + } + case EApIspIfCallbackEnabled: + { + aattr = R_APUI_VIEW_USE_CALL_BACK; + break; + } + case EApIspIfCallbackType: + { + aattr = R_APUI_VIEW_CALL_BACK_TYPE; + break; + } + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + { + aattr = R_APUI_VIEW_ENABLE_PPP_COMP; + break; + } + case EApIspInitString: + { + aattr = R_APUI_VIEW_MODEM_INIT_STRING; + break; + } + case EApIspUseLoginScript: + { + aattr = R_APUI_VIEW_USE_LOGIN_SCRIPT; + break; + } + case EApGprsPdpType: + { + aattr = R_APUI_VIEW_PDP_TYPE; + break; + } + case EApIP6DNSAddrFromServer: + { + aattr = R_APUI_VIEW_SET_DNS_SERVERS_IP; + break; + } + case EApWlanNetworkName: + { + aattr = R_APUI_VIEW_WLAN_NETWORK_NAME; + break; + } + case EApWlanNetworkMode: + { + aattr = R_APUI_VIEW_WLAN_NETWORK_MODE; + break; + } + case EApWlanSecurityMode: + { + aattr = R_APUI_VIEW_WLAN_SECURITY_MODE; + break; + } + case EApWlanScanSSID: + { + aattr = R_APUI_VIEW_WLAN_HIDDEN_NETWORK; + break; + } + case EApWlanChannelId: + { + aattr = R_APUI_VIEW_AD_HOC; + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + aattr = 0; + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetResId") + } + + + + +// --------------------------------------------------------- +// CApSettingsDlg::FillPopupSettingPageL +// --------------------------------------------------------- +// +CDesCArrayFlat* CApSettingsDlg::FillPopupSettingPageLC( TApMember aData, + TInt& aCurrvalue ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::FillPopupSettingPageLC") + + CDesCArrayFlat* items = new( ELeave)CDesCArrayFlat( 1 ); + CleanupStack::PushL( items ); + + TUint32 tval( 0 ); + + switch ( aData ) + { + case EApIspPromptForLogin: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PROMPT_PASSWD_YES ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PROMPT_PASSWD_NO ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, ETrue, aCurrvalue ); + break; + } + case EApWapSecurity: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WTLS_SECURITY_ON ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WTLS_SECURITY_OFF ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, ETrue, aCurrvalue ); + break; + } + case EApIspIfCallbackEnabled: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_USE_CB_YES ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_USE_CB_NO ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, ETrue, aCurrvalue ); + break; + } + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PPP_COMP_YES ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PPP_COMP_NO ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, ETrue, aCurrvalue ); + break; + } + case EApWapCurrentBearer: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_BEARER_TYPE_GPRS ) ); + CleanupStack::PopAndDestroy(); + + if ( IsWlanSupported() ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_BEARER_TYPE_WLAN ) ); + CleanupStack::PopAndDestroy(); + } + + TBool isCsdSupported = + FeatureManager::FeatureSupported( KFeatureIdAppCsdSupport ); +#ifdef __TEST_CSD_SUPPORT + isCsdSupported = ETrue; +#endif // __TEST_CSD_SUPPORT + + if ( isCsdSupported ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_BEARER_TYPE_CSD ) ); + CleanupStack::PopAndDestroy(); + + if ( IsHSCSDEnabledL() ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_BEARER_TYPE_HSCSD ) ); + CleanupStack::PopAndDestroy(); + } + } + aCurrvalue = BearerType2BearerItemPosL( iBearerType ); + break; + } + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PASSWORD_AUTH_NORMAL ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PASSWORD_AUTH_SECURE ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, EFalse, aCurrvalue ); + // needs to be inverted? + break; + } + case EApWapWspOption: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_CONN_TYPE_CONTIN ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_CONN_TYPE_TEMP ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( aData, tval ); + aCurrvalue = Min( 1, tval ); + aCurrvalue = !aCurrvalue; + break; + } + case EApIspBearerCallTypeIsdn: // used for data call type + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_DATACALL_ANALOLGUE ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_DATACALL_ISDN_110 ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_DATACALL_ISDN_120 ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( EApIspBearerCallTypeIsdn, tval ); + switch ( tval ) + { + case ECallTypeISDNv110: + { + aCurrvalue = KIspCallIsdn110; + break; + } + case ECallTypeISDNv120: + { + aCurrvalue = KIspCallIsdn120; + break; + } + default: + case ECallTypeAnalogue: + { + aCurrvalue = KIspCallAnalogue; + break; + } + } + break; + } + case EApIspBearerSpeed: + { + FillUpBearerSpeedValuesL( *items, aCurrvalue ); + break; + } + case EApIspIfCallbackType: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_CB_USE_SERVER_NUMBER ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_CB_USE_OTHER_NUMBER ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( aData, tval ); + if ( tval == ECallbackActionMSCBCPRequireClientSpecifiedNumber ) + { + aCurrvalue = 1; + } + else + { + aCurrvalue = 0; + } + break; + } + case EApIspUseLoginScript: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_USE_LOGINS_YES ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_USE_LOGINS_NO ) ); + CleanupStack::PopAndDestroy(); + GetBoolDataValue( aData, ETrue, aCurrvalue ); + break; + } + case EApGprsPdpType: + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PDP_TYPE_IPV4 ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_PDP_TYPE_IPV6 ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( aData, tval ); + if ( tval == EIPv6 ) + { + aCurrvalue = 1; + } + else + { + aCurrvalue = 0; + } + break; + } + case EApIP6DNSAddrFromServer: + { + TApBearerType b = iApItem->BearerTypeL(); + TBool hasAuto = ( b != EApBearerTypeCSD ) + && ( b != EApBearerTypeHSCSD ) ; + if ( hasAuto ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_NEW_AP_DNS_SERVERS_AUTOMATIC ) ); + CleanupStack::PopAndDestroy(); + } + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_SET_IP_WELL_KNOWN ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_SET_IP_USER_DEFINED ) ); + CleanupStack::PopAndDestroy(); + TBool bval; + iApItem->ReadBool( aData, bval ); + if ( !bval ) + { + aCurrvalue = GetIPv6DNSTypeL(); + if ( !hasAuto ) + { // no Auto item, dec. currvalue + aCurrvalue--; + } + } + else + { + aCurrvalue = 0; + } + break; + } + case EApWlanNetworkName: + { + if ( IsWlanSupported() ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_NETWORK_NAME_USER ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_NETWORK_NAME_SCAN ) ); + CleanupStack::PopAndDestroy(); + // set current value as user defined: if not yet given, + // it is true, if it had been already specified, + // we could not know if it was the user or was it scanned + aCurrvalue = 0; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanNetworkMode: + { + if ( IsWlanSupported() ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_NETWORK_MODE_INFRA ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_NETWORK_MODE_ADHOC ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( aData, tval ); + if ( tval == EAdhoc ) + { + aCurrvalue = 1; + } + else + { + aCurrvalue = 0; + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanScanSSID: + { + if ( IsWlanSupported() ) + { + TBool bval(EFalse); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_HIDDEN_NETWORK_NO ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_HIDDEN_NETWORK_YES ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadBool( aData, bval ); + if ( bval ) + { + aCurrvalue = 1; + } + else + { + aCurrvalue = 0; + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanChannelId: + { + if ( IsWlanSupported() ) + { + TUint32 channel(0); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_AD_HOC_CHANNEL_AUTO ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_AD_HOC_CHANNEL_USER_DEFINED ) ); + CleanupStack::PopAndDestroy(); + iApItem->ReadUint( aData, channel ); + if ( channel ) + { + aCurrvalue = 1; + } + else + { + aCurrvalue = 0; + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanSecurityMode: + { + if ( IsWlanSupported() ) + { + TUint32 netmode(0); + + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_SECURITY_MODE_WEP ) ); + CleanupStack::PopAndDestroy(); + + iApItem->ReadUint( EApWlanNetworkMode, netmode ); + if ( netmode == EInfra ) + { + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_SECURITY_MODE_802_1X ) ); + CleanupStack::PopAndDestroy(); + items->AppendL( *iEikonEnv->AllocReadResourceLC( + R_APUI_VIEW_WLAN_SECURITY_MODE_WPA ) ); + CleanupStack::PopAndDestroy(); + } + + iApItem->ReadUint( aData, tval ); + switch ( tval ) + { + case EOpen: + { + aCurrvalue = 0; + break; + } + case EWep: + { + aCurrvalue = 1; + break; + } + case E802_1x: + { + aCurrvalue = 2; + if ( netmode != EInfra ) + { + aCurrvalue--; + } + break; + } + case EWpa: + case EWpa2: + { + aCurrvalue = 3; + if ( netmode != EInfra ) + { + aCurrvalue-= 2; + } + break; + } + default: + { + aCurrvalue = 0; + break; + } + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic ( EUnknownCase ) ); + User::Leave( KErrInvalidColumn ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillPopupSettingPageLC") + return items; + } + + + + +// --------------------------------------------------------- +// CApSettingsDlg::UpdateFromPopupSettingPageL +// --------------------------------------------------------- +// +void CApSettingsDlg::UpdateFromPopupSettingPageL( TApMember aData, + TInt aCurrvalue ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateFromPopupSettingPageL") + + switch ( aData ) + { + case EApWapSecurity: + case EApIspPromptForLogin: + case EApIspIfCallbackEnabled: + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + case EApIspUseLoginScript: + { // INVERTED! + iApItem->WriteBool( aData, !( TBool( aCurrvalue ) ) ); + break; + } + case EApWlanScanSSID: + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + { // NOT INVERTED! + iApItem->WriteBool( aData, ( TBool( aCurrvalue ) ) ); + break; + } + case EApWapWspOption: + { + if ( aCurrvalue ) + { + iApItem->WriteUint( EApWapWspOption, + EWapWspOptionConnectionless ); + } + else + { + iApItem->WriteUint( EApWapWspOption, + EWapWspOptionConnectionOriented ); + } + break; + } + case EApWapCurrentBearer: + { + DoBearerChangeL( aCurrvalue ); + break; + } + case EApIspBearerSpeed: + { + iApItem->WriteUint( EApIspBearerSpeed, + GetBearerSpeedForSelection( aCurrvalue ) + ); + break; + } + case EApIspIfCallbackType: + { // UINT + if ( aCurrvalue ) + { + iApItem->WriteUint( EApIspIfCallbackType, + ECallbackActionMSCBCPRequireClientSpecifiedNumber ); + } + else + { + iApItem->WriteUint( EApIspIfCallbackType, + ECallbackActionMSCBCPAcceptServerSpecifiedNumber ); + } + break; + } + case EApIspBearerCallTypeIsdn: // used for data call type + { + // as order is the same in UI and in enum, simply write it + iApItem->WriteUint( EApIspBearerCallTypeIsdn, aCurrvalue ); + LimitSpeed(); + break; + } + case EApGprsPdpType: + { + // get value to write + if ( aCurrvalue ) + { + aCurrvalue = EIPv6; + } + else + { + aCurrvalue = EIPv4; + } + iApItem->WriteUint( EApGprsPdpType, aCurrvalue ); + break; + } + case EApIP6DNSAddrFromServer: + { + // if it is CSD or HSCSD, there is NO AUTOMATIC value, + // just the next two: Well-known & User defined... + // So in those cases, aCurrvalue must be 0 & 1, which + // corresponds to the normal 1, 2 so it should be incremented + TInt realvalue = aCurrvalue; + TApBearerType b = iApItem->BearerTypeL(); + if ( ( b == EApBearerTypeCSD ) || ( b == EApBearerTypeHSCSD ) ) + { + realvalue++; + } + + if ( realvalue == 2 ) + { // user defined!!! + TBool isip6( EFalse ); + if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) + { + TUint32 ival(0); + iApItem->ReadUint( EApGprsPdpType, ival ); + if ( ival == EIPv6 ) + { + isip6 = ETrue; + } + } + else + { + isip6 = !iL2Ipv4; + } + GetNameServersL( isip6 ); + } + else + { + if ( realvalue == 1 ) + { // well-known + // write default well known name server values + iApItem->WriteTextL( EApIP6NameServer1, + KKnownNameServer1 ); + iApItem->WriteTextL( EApIP6NameServer2, + KKnownNameServer2 ); + } + else + { + iApItem->WriteTextL( EApIP6NameServer1, KDynIpv6Address ); + iApItem->WriteTextL( EApIP6NameServer2, KDynIpv6Address ); + } + } + break; + } + case EApWlanNetworkMode: + { + if ( IsWlanSupported() ) + { + if ( aCurrvalue ) + { + iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); + LimitSecMode(); + } + else + { + iApItem->WriteUint( EApWlanNetworkMode, EInfra ); + } + + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanSecurityMode: + { + if ( IsWlanSupported() ) + { + TInt secmode(EOpen); + switch ( aCurrvalue ) + { + case KItemIndex0: + { + secmode = EOpen; + break; + } + case KItemIndex1: + { + secmode = EWep; + break; + } + case KItemIndex2: + { + secmode = E802_1x; + break; + } + case KItemIndex3: + { + secmode = EWpa; + break; + } + default: + { + secmode = EOpen; + break; + } + } + iApItem->WriteUint( EApWlanSecurityMode, secmode ); + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanChannelId: + { + if ( IsWlanSupported() ) + { + if ( aCurrvalue ) + { // user defined, ask number from user, offer 7 as default + TUint32 channel = GetAdHocChannelL(); + iApItem->WriteUint( EApWlanChannelId, channel ); + } + else + { // auto, write 0 + iApItem->WriteUint( EApWlanChannelId, aCurrvalue ); + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + User::Leave( KErrInvalidColumn ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateFromPopupSettingPageL") + } + + + +// --------------------------------------------------------- +// CApSettingsDlg::CanSaveL( ) +// --------------------------------------------------------- +// +CApSettingsDlg::TSaveAction CApSettingsDlg::CanSaveL( TApMember& aDataNeeded ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::CanSaveL") + + TSaveAction retval( EApCanSave ); + + // it is used in two cases, less code by doing it here + HBufC *sgd = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( sgd->Des() ); + + switch ( iBearerType ) + { + case EApBearerTypeCSD: + case EApBearerTypeHSCSD: + { + iApItem->ReadTextL( EApIspDefaultTelNumber, ptr ); + if ( *sgd == KEmptyText ) + { + retval = EApMustDelete; + if ( !( *iEventStore & KApUiEventExitRequested ) ) + { + if ( ! AskQueryL( R_APUI_AP_ACCESS_NUMBER_NOT ) ) + { + retval = EApShallGoBack; + aDataNeeded = EApIspDefaultTelNumber; + } + } + } + break; + } + case EApBearerTypeGPRS: + { + // nothing to do... + break; + } + case EApBearerTypeWLAN: + { + if ( IsWlanSupported() ) + { + iApItem->ReadTextL( EApWlanNetworkName, ptr ); + if ( *sgd == KEmptyText ) + { + retval = EApShallGoBack; + aDataNeeded = EApWlanNetworkName; + if ( !( *iEventStore & KApUiEventExitRequested ) ) + { + if ( AskQueryL( R_APUI_AP_WLAN_NAME_NOT_DEFINED ) ) + { + retval = EApMustDelete; + } + } + } + if ( (retval != EApShallGoBack) && (retval != EApMustDelete) + && IsNetMaskAndGatewayVisibleL() ) + { // now check compulsory fields + iApItem->ReadTextL( EApWlanIpNetMask, ptr ); + if ( ( ptr.Compare( KDynIpAddress ) == 0 ) + || ( ptr.Compare( KEmptyText ) == 0 ) ) + { + retval = EApShallGoBack; + aDataNeeded = EApWlanIpNetMask; + if ( AskQueryL( + R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) ) + { + retval = EApMustDelete; + } + } + else + { + iApItem->ReadTextL( EApIspIPGateway, ptr ); + if ( ( sgd->Compare( KDynIpAddress ) == 0 ) + || ( sgd->Compare( KEmptyText ) == 0 ) ) + { + retval = EApShallGoBack; + aDataNeeded = EApIspIPGateway; + if ( AskQueryL( + R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) + ) + { + retval = EApMustDelete; + } + } + } + } + if ( (retval != EApShallGoBack) && (retval != EApMustDelete) + && (!HasSecuritySettingsFilledL()) ) + { + retval = EApShallGoBack; + aDataNeeded = EApWlanSecuritySettings; + if ( !( *iEventStore & KApUiEventExitRequested ) ) + { + if ( AskQueryL( R_APUI_AP_WLAN_SEC_SETT_EMPTY ) ) + { + retval = EApMustDelete; + } + } + } + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + { // in release, leave, in debug, PANIC + __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); + User::Leave( KErrInvalidBearerType ); + break; + } + } + CleanupStack::PopAndDestroy( sgd ); // sgd + + if ( ( retval == EApShallGoBack ) && + ( *iEventStore & KApUiEventExitRequested ) ) + { + retval = EApNoAction; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::CanSaveL") + return retval; + } + + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::ShowPopupIpAddrSettingPageL +//---------------------------------------------------------- +// +void CApSettingsDlg::ShowPopupIpAddrSettingPageL( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupIpAddrSettingPageL") + + HBufC* aBuf = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( aBuf->Des() ); + + iApItem->ReadTextL( aData, ptr ); + + TBuf textToChange; + + textToChange.Append( ptr ); + + TInt page_resid( 0 ); + TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); + GetTextResId( aData, page_resid, TextSettingPageFlags ); + + TInetAddr AddrToChange; + AddrToChange.Input( textToChange ); + CAknIpFieldSettingPage* dlg = + new( ELeave )CAknIpFieldSettingPage( page_resid, AddrToChange ); + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + // first need to check phone number validity, if not, + // display error msg, + AddrToChange.Output( textToChange ); + iApItem->WriteTextL( aData, textToChange ); + } + CleanupStack::PopAndDestroy(); // aBuf + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupIpAddrSettingPageL") + } + + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::ShowPopupPhoneNumSettingPageL +//---------------------------------------------------------- +// +void CApSettingsDlg::ShowPopupPhoneNumSettingPageL( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupPhoneNumSettingPageL") + + HBufC* aBuf = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( aBuf->Des() ); + + if ( aData == EApIspIfCallbackInfo ) + { // 8 bit text + HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); + TPtr8 ptr8( tmpValue8->Des() ); + iApItem->ReadTextL( aData, ptr8 ); + ptr.Copy( ptr8 ); + CleanupStack::PopAndDestroy(); // tmpvalue8 + } + else + { + iApItem->ReadTextL( aData, ptr ); + } + + TBuf textToChange; + + textToChange.Append( ptr ); + + TInt page_resid( 0 ); + TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); + GetTextResId( aData, page_resid, TextSettingPageFlags ); + TBool mustgoon( ETrue ); + do + { + CAknSettingPage* dlg = + new( ELeave )CAknTextSettingPage( page_resid, + textToChange, + TextSettingPageFlags ); + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + // first need to check phone number validity, + // if not, dispaly error msg, + // bearing in mind that if empty is not allowed, + // we can not got empty text from editor, so IF it is not a valid + // phone number, but it is empty, thna it is allowed and + // it is the user's wish, so go on as valid... + // MNAN-6XBFNB: Digits that are not western should also be accepted + // Convert digits to western and check the phone number like this. + TBuf temp; + temp = textToChange; + AknTextUtils::ConvertDigitsTo( temp, EDigitTypeWestern ); + + if ( CommonPhoneParser::IsValidPhoneNumber + ( temp, CommonPhoneParser::EContactCardNumber ) + || ( temp.Compare( KEmpty ) == 0) ) + { + if ( aData == EApIspIfCallbackInfo ) + { // 8 bit text + HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); + TPtr8 ptr8( tmpValue8->Des() ); + iApItem->ReadTextL( aData, ptr8 ); + ptr8.Copy( textToChange ); + iApItem->WriteTextL( aData, ptr8 ); + CleanupStack::PopAndDestroy(); // tmpvalue8 + } + else + { + iApItem->WriteTextL( aData, textToChange ); + } + mustgoon = EFalse; + } + else + { // give invalid number message + ShowNoteL( R_APUI_VIEW_INVALID_NUMBER ); + } + } + else + { + mustgoon = EFalse; + } + } + while( mustgoon ); + CleanupStack::PopAndDestroy(); // aBuf + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupPhoneNumSettingPageL") + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::ShowPopupPasswordPageL +//---------------------------------------------------------- +// +void CApSettingsDlg::ShowPopupPasswordPageL( TApMember aData ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupPasswordPageL") + + // must be prepared for the worst case... + TBuf newpass; + + TUint32 txtLength = iApItem->ReadTextLengthL( aData ); + // allocates as much as needed... + HBufC* oldpass = HBufC::NewLC( txtLength ); + TPtr16 ptr( oldpass->Des() ); + iApItem->ReadTextL( aData, ptr ); + + CAknAlphaPasswordSettingPage* dlg = + new( ELeave )CAknAlphaPasswordSettingPage( + R_TEXT_SETTING_PAGE_LOGIN_PASSWD, + newpass, ptr ); + CleanupStack::PushL(dlg); + // As password is asked only once... + dlg->SetMaxPasswordLength( KMaxLoginPasswordLength ); + CleanupStack::Pop(); + if ( dlg->ExecuteLD(CAknSettingPage::EUpdateWhenChanged) ) + { + iApItem->WriteTextL( aData, newpass ); + } + CleanupStack::PopAndDestroy(); // oldpass + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupPasswordPageL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetBoolDataValue +//---------------------------------------------------------- +// +void CApSettingsDlg::GetBoolDataValue( TApMember aData, TBool aInvert, + TInt& aCurrvalue) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetBoolDataValue") + + iApItem->ReadBool( aData, aCurrvalue); + // just to be on the sure side... + aCurrvalue = Min( KBoolMaxNumber, aCurrvalue); + if ( aInvert) + { + aCurrvalue = !aCurrvalue; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetBoolDataValue") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::DoBearerChangeL +//---------------------------------------------------------- +// +void CApSettingsDlg::DoBearerChangeL( TInt aCurrvalue) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::DoBearerChangeL") + + TApBearerType newbearer = BearerItemPos2BearerTypeL( aCurrvalue ); + HandleBearerChangeL( newbearer ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::DoBearerChangeL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::HandleBearerChangeL +//---------------------------------------------------------- +// +void CApSettingsDlg::HandleBearerChangeL( TApBearerType aBearer) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleBearerChangeL") + + if ( iBearerItemArray->At( BearerToArrayIndexL( aBearer)) == NULL) + { + CApAccessPointItem* ap = CApAccessPointItem::NewLC(); + ap->CopyFromL( *iApItem); + ap->WriteUint( EApWapAccessPointID, iApItem->WapUid()); + iBearerItemArray->At( BearerToArrayIndexL( aBearer)) = ap; + iApItem = ap; + CleanupStack::Pop(); // ap + } + else + { + iApItem = iBearerItemArray->At( BearerToArrayIndexL( aBearer)); + } + iApItem->SetBearerTypeL( aBearer ); + SetBearerTypeL( aBearer ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleBearerChangeL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::BearerToArrayIndexL +//---------------------------------------------------------- +// +TInt32 CApSettingsDlg::BearerToArrayIndexL( TApBearerType aBearer) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::BearerToArrayIndexL") + + TInt32 retval( KBearerArrayGPRS ); + switch( aBearer ) + { + case EApBearerTypeCSD: + { + retval = KBearerArrayCSD; + break; + } + case EApBearerTypeGPRS: + { + retval = KBearerArrayGPRS; + break; + } + case EApBearerTypeHSCSD: + { + retval = KBearerArrayHSCSD; + break; + } + case EApBearerTypeWLAN: + { + if ( IsWlanSupported() ) + { + retval = KBearerArrayWLAN; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); + User::Leave( KErrInvalidBearerType ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::BearerToArrayIndexL") + return retval; + } + +/* +//---------------------------------------------------------- +// CApSettingsDlg::ArrayIndexToBearer +//---------------------------------------------------------- +// +TApBearerType CApSettingsDlg::ArrayIndexToBearer( TInt32 aIndex) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ArrayIndexToBearer") + + TApBearerType retval( EApBearerTypeGPRS ); + switch( aIndex ) + { + case KBearerArrayCSD: + { + retval = EApBearerTypeCSD; + break; + } + case KBearerArrayGPRS: + { + retval = EApBearerTypeGPRS; + break; + } + case KBearerArrayHSCSD: + { + retval = EApBearerTypeHSCSD; + break; + } + case KBearerArrayWLAN: + { + if ( IsWlanSupported() ) + { + retval = EApBearerTypeWLAN; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ArrayIndexToBearer") + return retval; + } + +*/ + + +//---------------------------------------------------------- +// CApSettingsDlg::FillUpBearerSpeedValuesL +//---------------------------------------------------------- +// +void CApSettingsDlg::FillUpBearerSpeedValuesL( CDesCArrayFlat& aItems, + TInt& aCurrvalue ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::FillUpBearerSpeedValuesL") + + TUint32 tval( 0 ); + TUint32 bval( 0 ); + + iApItem->ReadUint( EApIspBearerSpeed, tval ); + iApItem->ReadUint( EApIspBearerCallTypeIsdn, bval ); + TApBearerType btype = iApItem->BearerTypeL(); + const TInt* actResSpeeds = NULL; + const TInt* actSpeeds = NULL; + + TBool isWcdma = + FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); + + switch ( bval ) + { + case ECallTypeAnalogue: + { // CSD/HSCSD, Analogue + if ( btype == EApBearerTypeHSCSD ) + { + actResSpeeds = KResHcsdAnalogue; + actSpeeds = KHcsdAnalogue; + } + else + { + actResSpeeds = KResCsdAnalogue; + actSpeeds = KCsdAnalogue; + if ( isWcdma ) + { + actResSpeeds = KResCsdAnalogueWcdma; + actSpeeds = KCsdAnalogueWcdma; + } + } + break; + } + case ECallTypeISDNv110: + { // CSD/HSCSD, ISDN v110: + if ( btype == EApBearerTypeHSCSD ) + { + actResSpeeds = KResHcsdIsdn110; + actSpeeds = KHcsdIsdn110; + } + else + { + actResSpeeds = KResCsdIsdn110; + actSpeeds = KCsdIsdn110; + if ( isWcdma ) + { + actResSpeeds = KResCsdIsdn110Wcdma; + actSpeeds = KCsdIsdn110Wcdma; + } + } + break; + } + case ECallTypeISDNv120: + { + if ( btype == EApBearerTypeHSCSD ) + { + actResSpeeds = KResHcsdIsdn120; + actSpeeds = KHcsdIsdn120; + } + else + { + actResSpeeds = KResCsdIsdn120; + actSpeeds = KCsdIsdn120; + if ( isWcdma ) + { + actResSpeeds = KResCsdIsdn120Wcdma; + actSpeeds = KCsdIsdn120Wcdma; + } + } + break; + } + default: + { + break; + } + } + + if ( actResSpeeds ) + { + while ( *actResSpeeds != KEndOfArray ) + { + aItems.AppendL( *iEikonEnv->AllocReadResourceLC( *actResSpeeds ) ); + CleanupStack::PopAndDestroy(); + ++actResSpeeds; + } + } + + if( actSpeeds ) + { + aCurrvalue = 0; + TInt nextSpeed = *( actSpeeds + aCurrvalue + 1) ; + while ( ( nextSpeed != KEndOfArray ) + && ( *( actSpeeds + aCurrvalue) < ( TInt )tval ) + && ( nextSpeed <= ( TInt )tval ) ) + { + ++aCurrvalue; + nextSpeed = *( actSpeeds + aCurrvalue + 1) ; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillUpBearerSpeedValuesL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::SaveDataL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::SaveDataL( ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::SaveDataL") + + TApMember aDataNeeded; + TSaveAction action(EApCanSave); + TBool retval( ETrue ); + TInt err (KErrNone ); + + // first handle ALL db stuff because Symbian DB does handles + // consequtive transactions wrongly... + TTransactionResult ownTransaction = + iDataModel->StartTransactionLC( + /*aWrite*/EFalse, + /*aShowNote*/ETrue, + /*aRetry*/ETrue ); + if ( ownTransaction != EFailedWithLocked ) + { + action = CanSaveL(aDataNeeded); + switch ( action ) + { + case EApCanSave: +#ifdef __WINS__ + case EApMustDelete: +#endif // __WINS__ + { // save data + if ( ( *iOldApItem != *iApItem ) || ( *iUid == KApNoneUID ) + || iDataModel->iWepSecSettings + || iDataModel->iWpaSecSettings ) + { // save if different or NEW BLANK + *iEventStore |= KApUiEventEdited; + if ( *iUid == KApNoneUID ) + { + HBufC* buf = HBufC::NewLC( KApMaxConnNameLength ); + // now check if name is unique, if it is, + // save and commit, if it is not, show note + // and no save at all, Rollback! + TPtr16 ptr( buf->Des() ); + iApItem->ReadTextL( EApWapAccessPointName, ptr ); + TBool b(EFalse); + TRAP( err, b = + iDataModel->ApUtils()->IsValidNameL( ptr ) ); + CleanupStack::PopAndDestroy( buf ); + if ( b ) + { + TRAP( err, + iDataModel->CreateFromDataL( *iApItem ) ); + if ( err == KErrNone ) + { + iApItem->ReadUint( EApWapAccessPointID, + *iUid ); + *iEventStore |= KApUiEventCreatedBlank; + } + } + else + { + err = KErrAlreadyExists; + // no DB call after this point, as transaction must be rolled back, + // but we can do it only at the end + if ( ownTransaction == EOwnTransaction ) + { + CleanupStack::PopAndDestroy(); //Rollback + // set as if no need to commit... + ownTransaction = EUsingAlreadyStarted; + } + } + } + else + { + // If the name is not unique, + // it will leave with KErrAlreadyExists + TRAP( err, + iDataModel->UpdateAccessPointDataL( *iApItem ) ); + } + } + break; + } +#ifndef __WINS__ + case EApMustDelete: + { + if ( *iUid != KApNoneUID ) + { + TUint32 WapUid( 0 ); + iApItem->ReadUint( EApWapAccessPointID, WapUid ); + iDataModel->RemoveApL( WapUid ); + } + break; + } +#endif // __WINS__ + case EApShallGoBack: + { + switch ( aDataNeeded ) + { + case EApIspDefaultTelNumber: + { + SelectItem( KListIndexCSDAccessNumber ); + retval = EFalse; + break; + } + case EApWlanNetworkName: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANNetworkName ); + retval = EFalse; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanIpNetMask: + case EApIspIPNetMask: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANSubnetMask ); + retval = EFalse; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApIspIPGateway: + case EApWlanIpGateway: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANDefaultGateway ); + retval = EFalse; + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanSecuritySettings: + { + if ( IsWlanSupported() ) + { + SelectItem( KListIndexWLANSecuritySettings ); + retval = EFalse; + ChangeSettingsL( EFalse ); + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + default: + {// otherwise, nothing to do... + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case EApNoAction: + { // can not save, do not go back: Exit, do nothing but ignore... + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + if ( ownTransaction == EOwnTransaction ) + { + err = iDataModel->Database()->Database()->CommitTransaction(); + User::LeaveIfError( err ); + CleanupStack::Pop(); // RollbackTransaction + } + } + else + { + User::Leave( KErrLocked ); + } + // end transaction stuff + // and handle possible other stuff like + // displaying notifications, redirecting the user, etc... + + if ( err == KErrAlreadyExists ) + { + // Check if exit and if it is, Exit, + // if it is not, then show note + // and move user back to editor... + if ( !( *iEventStore & KApUiEventExitRequested ) ) + { + HBufC* buf = HBufC::NewLC( KApMaxConnNameLength ); + TPtr16 ptr( buf->Des() ); + iApItem->ReadTextL( EApWapAccessPointName, ptr ); + ShowNoteL( R_APUI_IAP_NAME_ALREADY_EXISTS, buf ); + CleanupStack::PopAndDestroy( buf ); // buf + SelectItem( KListIndexConnectionName ); + retval = EFalse; + ChangeSettingsL( EFalse ); + } + } + else + { + if ( err == KErrInvalidName ) + { + ShowNoteL( R_APUI_VIEW_INVALID_CONN_NAME ); + SelectItem( KListIndexConnectionName ); + retval = EFalse; + } + else + { + if ( !( *iEventStore & KApUiEventExitRequested ) ) + { + User::LeaveIfError( err ); + } + iOldApItem->CopyFromL( *iApItem ); + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::SaveDataL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::HandleListStructureChangeL +//---------------------------------------------------------- +// +void CApSettingsDlg::HandleListStructureChangeL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListStructureChangeL") + + TUint32 l = iApItem->ReadTextLengthL( EApWapGatewayAddress ); + HBufC* buf = HBufC::NewLC( l ); + TPtr16 ptr( buf->Des() ); + iApItem->ReadTextL( EApWapGatewayAddress, ptr ); + + if ( ( iBearerType == EApBearerTypeCSD ) + || ( iBearerType == EApBearerTypeHSCSD ) ) + { + GetCSDSettingArrays( iVariant ); + } + else + { + if ( iBearerType == EApBearerTypeGPRS ) + { + GetGPRSSettingArrays( iVariant ); + } + else + { + if ( IsWlanSupported() ) + { + if ( iBearerType == EApBearerTypeWLAN ) + { + GetWLANSettingArraysL( iVariant ); + } + else + { + User::Leave( KErrInvalidBearer ); + } + } + else + { + User::Leave( KErrInvalidBearer ); + } + } + } + CleanupStack::PopAndDestroy( buf ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListStructureChangeL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::LimitSpeed +//---------------------------------------------------------- +// +void CApSettingsDlg::LimitSpeed() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::LimitSpeed") + + // now 'limit' the speeds + TUint32 speed( 0 ); + iApItem->ReadUint( EApIspBearerSpeed, speed ); + TUint32 calltype( EFalse ); + iApItem->ReadUint( EApIspBearerCallTypeIsdn, calltype ); + const TInt* actSpeeds = NULL; + TBool isWcdma = + FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ) ; + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + switch ( calltype ) + { + case ECallTypeISDNv110: + { + actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; + break; + } + case ECallTypeISDNv120: + { + actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; + break; + } + case ECallTypeAnalogue: + default: + { + actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; + } + } + break; + } + case EApBearerTypeHSCSD: + { + switch ( calltype ) + { + case ECallTypeISDNv110: + { + actSpeeds = KHcsdIsdn110; + break; + } + case ECallTypeISDNv120: + { + actSpeeds = KHcsdIsdn120; + break; + } + case ECallTypeAnalogue: + default: + { + actSpeeds = KHcsdAnalogue; + } + } + break; + } + default: + { + break; + } + } + + if( actSpeeds ) + { + TInt tempSpeed = *actSpeeds; + TInt nextSpeed = *( actSpeeds + 1 ); + while ( ( nextSpeed != KEndOfArray ) + && ( tempSpeed < ( TInt )speed ) + && ( nextSpeed <= ( TInt )speed ) ) + { + tempSpeed = *( ++actSpeeds ); + nextSpeed = *( actSpeeds + 1 ); + } + speed = tempSpeed ; + } + + + iApItem->WriteUint( EApIspBearerSpeed, speed ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::LimitSpeed") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::SelectItem +//---------------------------------------------------------- +// +void CApSettingsDlg::SelectItem( TInt aItemIndex ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::SelectItem") + + iList->ScrollToMakeItemVisible( aItemIndex ); + iList->SetCurrentItemIndexAndDraw( aItemIndex ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::SelectItem") + } + + + + + +// Converting EParagraphDelimiters to \ns +// --------------------------------------------------------- +// CApSettingsDlg::ConvertDelimToPerNLC +// --------------------------------------------------------- +// +HBufC* CApSettingsDlg::ConvertDelimToPerNLC( const TDesC& aInText ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ConvertDelimToPerNLC") + + TInt size = aInText.Length(); + HBufC* outText = HBufC::NewLC( size ); + TPtr ptr = outText->Des(); + + for ( TInt ii=0; iiDes(); + + TText ch; + for (TInt ii=0; iiCurrentItemIndex(), 0 ) ); + TApMember* ptr; + TInt* tptr; + TInt* compulsptr; + switch ( iLevel ) + { + case 0: + { + ptr = iField; + tptr = iTitles; + compulsptr = iCompulsory; + break; + } + case 1: + { + ptr = iFieldAdvanced; + tptr = iTitlesAdvanced; + compulsptr = iCompulsoryAdvanced; + break; + } + case 2: + { + ptr = iFieldL2; + tptr = iTitlesL2; + compulsptr = iCompulsoryL2; + break; + } + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + return; // just to suppress warnings about ptr's + // beeing used uninitialised + } + } + + + + ptr += itemnum; + tptr += itemnum; + compulsptr += itemnum; + TInt topitem( iList->TopItemIndex() ); + + TApBearerType bearer = iApItem->BearerTypeL(); + if ( bearer == EApBearerTypeGPRS ) + { + TUint32 tint; + iApItem->ReadUint( EApGprsPdpType, tint ); + if ( tint == EIPv6 ) + { + if ( iLevel == 1 ) + { + if ( itemnum ) + { + ptr++; + tptr++; + compulsptr++; + } + } + } + } + else + { // others + if ( bearer == EApBearerTypeWLAN ) + { + // if we are in iL2Ipv4, AND + // EApIspIPNetMask and EApIspIPGateway fields are not added + // skip those items... + if ( !IsNetMaskAndGatewayVisibleL() ) + { + if ( *ptr == EApIspIPNetMask ) + { + ptr++; + tptr++; + compulsptr++; + } + if ( *ptr == EApIspIPGateway ) + { + ptr++; + tptr++; + compulsptr++; + } + } + if ( !IsAdhocChannelVisible() ) + { + if ( ( *ptr == EApWlanChannelId ) + || ( *ptr == EApProxyServerAddress ) ) + { + ptr++; + tptr++; + compulsptr++; + } + } + } + else + { + // CSD + if ( *ptr == EApIspIPAddr ) + { + if ( !iL2Ipv4 ) + { + ptr++; + tptr++; + compulsptr++; + } + } + } + } + + + switch ( *ptr ) + { + case EApIspPromptForLogin: + case EApWapSecurity: + case EApIspIfCallbackEnabled: + case EApIspEnableSWCompression: + case EApGprsHeaderCompression: + case EApIspUseLoginScript: + case EApGprsDisablePlainTextAuth: + case EApIspDisablePlainTextAuth: + case EApWapWspOption: + case EApIspIfCallbackType: + case EApGprsPdpType: + case EApWlanNetworkMode: + case EApWlanScanSSID: + { // type 4 setting item with two available values + TBool changed( ETrue ); + if ( aQuick ) + { + InvertSettingsL( *ptr ); + } + else + { + changed = ShowPopupSettingPageL( *ptr ); + } + if ( changed ) + { + if ( *ptr == EApGprsPdpType ) + { + HandleListboxDataChangeL( EFalse ); + } + UpdateOnOffListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + if ( *ptr == EApWlanNetworkMode ) + { + UpdateOnOffListBoxItemL( *( ptr+1 ), *( tptr+1 ), + itemnum+1, + *( compulsptr + 1 ) ); + if ( (itemnum+1) <= iList->BottomItemIndex() ) + { + iList->DrawItem( itemnum+1 ); + } + } + } + break; + } + case EApIspDefaultTelNumber: + case EApIspIfCallbackInfo: + { // type 1, Phone number editor + ShowPopupPhoneNumSettingPageL( *ptr ); + UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + break; + } + case EApWapGatewayAddress: + case EApIspIPAddr: + case EApIspIPNetMask: + case EApWlanIpNetMask: + case EApIspIPGateway: + case EApWlanIpGateway: + case EApGprsIPNameServer1: + case EApIspIPNameServer1: + case EApGprsIPNameServer2: + case EApIspIPNameServer2: + {// above ones are type 1, IP Address editors! + ShowPopupIpAddrSettingPageL( *ptr ); + UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + if ( *ptr == EApWapGatewayAddress ) + { + HandleListStructureChangeL(); + HandleListboxDataChangeL( EFalse ); + } + if ( *ptr == EApIspIPAddr ) + { + HandleListboxDataChangeL( EFalse ); + } + break; + } + case EApWapAccessPointName: + case EApGprsAccessPointName: + case EApIspLoginName: + case EApIspIfAuthName: + case EApIspLoginScript: + case EApWapStartPage: + case EApIspInitString: + case EApProxyServerAddress: + case EApProxyPortNumber: + { // type 1, Text setting item + if ( ShowPopupTextSettingPageL( *ptr ) ) + { + UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + if ( *ptr == EApWapAccessPointName ) + { + iTitlePane->SetTextL( iApItem->ConnectionName() ); + } + } + break; + } + case EApIspLoginPass: + case EApIspIfAuthPass: + + { // re-confirm, secreted, etc, + ShowPopupPasswordPageL( *ptr ); + UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + break; + } + case EApWapCurrentBearer: + case EApIspBearerCallTypeIsdn: // used for data call type + case EApIspBearerSpeed: + case EApWlanChannelId: + { // type 2, Pop-up setting item + if ( ShowPopupSettingPageL( *ptr ) ) + { + if ( *ptr == EApWapCurrentBearer ) + { + // if ==, the whole list needs to be updated ! + SetBearerTypeL( iApItem->BearerTypeL() ); + LimitSpeed(); + HandleListboxDataChangeL( EFalse ); + iList->SetTopItemIndex( topitem ); + iList->DrawNow(); + } + else + { + if ( *ptr == EApIspBearerCallTypeIsdn ) + { // first limit the speed if neccessary + LimitSpeed(); + // need to redraw EApIspBearerSpeed, too + // because it is possible that it had been changed + // to keep constrains simply update next field, + // too, 'cause they are next to each other... + UpdateOnOffListBoxItemL( *( ptr+1 ), *( tptr+1 ), + itemnum+1, + *( compulsptr + 1 ) ); + iList->DrawItem( itemnum+1 ); + } + UpdateOnOffListBoxItemL( *ptr, *tptr, + itemnum, *compulsptr ); + } + } + break; + } + case EApWlanSecurityMode: + { // type 2, Pop-up setting item + if ( ShowPopupSettingPageL( *ptr ) ) + { + // security mode has changed, re-create security settings! + UpdateOnOffListBoxItemL( *ptr, *tptr, + itemnum, *compulsptr ); + iHandler->iModel->UpdateSecurityModeL( *iApItem ); + } + break; + } + case EApIP6DNSAddrFromServer: + { + // if GPRS, PDP type Ipv4, DNS data query + // if GPRS, PDP type Ipv6, type 2, Pop-up setting item + TUint32 ival(0); + iApItem->ReadUint( EApGprsPdpType, ival ); + TBool changed( EFalse ); + if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) + { + if ( ival == EIPv6 ) + { + // GPRS, PDP type Ipv6, DNS pop-up setting item + changed = ShowPopupSettingPageL( *ptr ); + } + else + { + // GPRS, PDP type Ipv4, DNS data query + changed = GetNameServersL( EFalse ); + } + } + else + { // CSD/HSCSD + if ( iL2Ipv4 ) + { + changed = GetNameServersL( EFalse ); + } + else + { + changed = ShowPopupSettingPageL( *ptr ); + } + } + if ( changed ) + { + UpdateOnOffListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + } + break; + } + case EApNetworkName: + { + ChangeNetworkGroupL(); + UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); + break; + } + case EApIpv4Settings: + case EApIpv6Settings: + { + iL2Ipv4 = ( *ptr == EApIpv4Settings ); + if ( iLevel ) + { + // enter Ipv4 or Ipv6 settings + if ( iL2Ipv4 ) + { + // save current state so we can roll back to it + // if needed, e.g. if user fills but discards values... + if (!iBackupApItem ) + { + iBackupApItem = CApAccessPointItem::NewLC(); + CleanupStack::Pop(); // member var + } + iBackupApItem->CopyFromL( *iApItem ); + } + iLevel++; + HandleListStructureChangeL(); + iOldIndex = iList->CurrentItemIndex(); + iOldTopIndex = iList->TopItemIndex(); + iList->SetCurrentItemIndex( 0 ); + HandleListboxDataChangeL( EFalse ); + itemnum = 0; + } + break; + } + case EApWlanNetworkName: + { + if ( IsWlanSupported() ) + { + // Temporarily use plain text editor to input + // network name... + ChangeWlanNetworkNameL(); + // as it sets connection mode and security mode, + // we must update the full list... + HandleListboxDataChangeL( EFalse ); + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } + case EApWlanSecuritySettings: + { + if ( IsWlanSupported() ) + { + iSecSettingsExitReason = ChangeWlanSecuritySettingsL(); + } + else + { + User::Leave( KErrNotSupported ); + } + break; + } +/* + case EApWlanChannelId: + { + breaaak; + } +*/ + default: + { + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + SelectItem( itemnum ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::DoChangeSettingsL") + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetSpeedForSelection +//---------------------------------------------------------- +// +TApCallSpeed CApSettingsDlg::GetBearerSpeedForSelection( TInt aCurrvalue ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetBearerSpeedForSelection") + + TApCallSpeed sp( KSpeed9600 ); + + + TUint32 tval( 0 ); + iApItem->ReadUint( EApIspBearerCallTypeIsdn, tval ); + + const TInt* actSpeeds = NULL; + TBool isWcdma = + FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); + + switch ( tval ) + { + case ECallTypeAnalogue: + { // CSD/HSCSD, Analogue + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdAnalogue; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case ECallTypeISDNv110: + { + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdIsdn110; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case ECallTypeISDNv120: + { + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdIsdn120; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + sp = (TApCallSpeed) *(actSpeeds + aCurrvalue); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetBearerSpeedForSelection") + return sp; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetCurrIndexFromBearerSpeed +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetCurrIndexFromBearerSpeed( ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetCurrIndexFromBearerSpeed") + + TUint32 tval( 0 ); + TUint32 bval( 0 ); + TInt retval( 0 ); + + iApItem->ReadUint( EApIspBearerSpeed, tval ); + iApItem->ReadUint( EApIspBearerCallTypeIsdn, bval ); + + TBool isWcdma = + FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); + + const TInt* actSpeeds = NULL; + + switch ( bval ) + { + case ECallTypeAnalogue: + { // CSD/HSCSD, Analogue + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdAnalogue; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case ECallTypeISDNv110: + { + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdIsdn110; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + case ECallTypeISDNv120: + { + switch ( iBearerType ) + { + case EApBearerTypeCSD: + { + actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; + break; + } + case EApBearerTypeHSCSD: + { + actSpeeds = KHcsdIsdn120; + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + break; + } + default: + { + // this can only mean programmer error as no other + // bearer type is supperted with speed settings + __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); + break; + } + } + + if( actSpeeds ) + { + retval = 0; + while ( ( *( actSpeeds + retval + 1) != KEndOfArray ) + && ( *( actSpeeds + retval) < ( TInt )tval ) + && ( *( actSpeeds + retval + 1) <= ( TInt )tval ) ) + { + ++retval; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetCurrIndexFromBearerSpeed") + return retval; + } + + +//---------------------------------------------------------- +// CApSettingsDlg::ReplaceNonPrintingCharactersLC +//---------------------------------------------------------- +// +HBufC* CApSettingsDlg::ReplaceWhiteSpaceCharactersLC( const TDesC& aInText ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ReplaceWhiteSpaceCharactersLC") + + TInt size = aInText.Length(); + HBufC* aOutText = HBufC::NewLC( size ); + + TPtr ptr = aOutText->Des(); + + for ( TInt ii=0; iiiModel->EikEnv()->AllocReadResourceLC + ( + R_APUI_VIEW_NETWORK_GROUP + ); + + // needs this Dummy array to pass it to CAknSettingPage's constructor... + CDesCArrayFlat* aItemArray = new ( ELeave ) CDesCArrayFlat( 1 ); + CleanupStack::PushL( aItemArray ); + TUint32 prefUid( 0 ); + TInt currsel( -1 ); + iApItem->ReadUint( EApNetworkID, prefUid ); + + TInt prefInt( prefUid ); + CApNetSelPopupList* dlg = + CApNetSelPopupList::NewL( *iDataModel, *iHandler, currsel, + prefInt, *iEventStore, + aItemArray, ETrue ); + + CleanupStack::PushL( dlg ); + TPtrC ptr( titlebuf->Des() ); + dlg->SetSettingTextL( ptr ); + // dlg must be Pop-ed because ExecuteLD starts with PushL()... + CleanupStack::Pop(); + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) ) + { + // update value in iApItem + // get networkitem and add it to item... + iApItem->WriteUint( EApNetworkID, prefInt ); + // update network data according to new ID + iDataModel->DataHandler()->ReadNetworkPartL( *iApItem ); + } + CleanupStack::PopAndDestroy( aItemArray ); // aItemArray + CleanupStack::PopAndDestroy( titlebuf ); // titlebuf + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeNetworkGroupL") + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::IsHSCSDEnabledL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::IsHSCSDEnabledL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::IsHSCSDEnabledL") + + TInt EnableHSCSD( ETrue ); + +/* + // Connecting and initialization: + TInt err( KErrNone ); + CRepository* repository; + TRAP( err, repository = CRepository::NewL( KGeneralSettingsUid ) ); +// repository->Get( KGSHSCSDAccessPoints, EnableHSCSD ); + delete repository; +*/ + +#ifdef __TEST_NO_HSCSD + EnableHSCSD = EFalse; +#endif +#ifdef __TEST_HSCSD_SUPPORT + EnableHSCSD = ETrue; +#endif // __TEST_HSCSD_SUPPORT + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsHSCSDEnabledL") + return EnableHSCSD; + } + + + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetCSDSettingArrays +//---------------------------------------------------------- +// +void CApSettingsDlg::GetCSDSettingArrays( TInt variant ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetCSDSettingArrays") + + // If IPv6 support requested, is the only place where L2 level needed, + // so it is the only place when it is variated... + if ( iReqIpvType & EIPv6 ) + { + if ( iL2Ipv4 ) + { + iFieldL2 = + (TApMember*) &Fields_CSD_L2_IPv4[KApMember][0]; + iFieldCountL2 = + sizeof( Fields_CSD_L2_IPv4[KApMember] )/sizeof( TApMember ); + iTitlesL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv4[KResourceID][0] ); + iCompulsoryL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv4[KCompulsory][0] ); + } + else + { + iFieldL2 = + (TApMember*) &Fields_CSD_L2_IPv6[KApMember][0]; + iFieldCountL2 = + sizeof( Fields_CSD_L2_IPv6[KApMember] )/sizeof( TApMember ); + iTitlesL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv6[KResourceID][0] ); + iCompulsoryL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv6[KCompulsory][0] ); + } + } + + + + if ( variant & KWSPSettingsVisible ) + { + if ( iReqIpvType & EIPv6 ) + { + iField = (TApMember*) &Fields_CSD_WSP_IPv6[KApMember][0]; + iFieldCount = + sizeof( Fields_CSD_WSP_IPv6[KApMember] )/sizeof( TApMember ); + + iFieldAdvanced = + (TApMember*) &Fields_CSD_Advanced_WSP_IPv6[KApMember][0]; + iAdvancedFieldCount = + sizeof( Fields_CSD_Advanced_WSP_IPv6[KApMember] ) + / sizeof( TApMember ); + + iTitles = + MUTABLE_CAST( TInt*, &Fields_CSD_WSP_IPv6[KResourceID][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_WSP_IPv6[KResourceID][0] ); + + iCompulsory = + MUTABLE_CAST( TInt*, + &Fields_CSD_WSP_IPv6[KCompulsory][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_WSP_IPv6[KCompulsory][0] ); + + } + else + { + iField = (TApMember*) &Fields_CSD_WSP[KApMember][0]; + iFieldCount = + sizeof( Fields_CSD_WSP[KApMember] )/sizeof( TApMember ); + + iFieldAdvanced = + (TApMember*) &Fields_CSD_Advanced_WSP[KApMember][0]; + iAdvancedFieldCount = + sizeof( Fields_CSD_Advanced_WSP[KApMember] ) + / sizeof( TApMember ); + + iTitles = + MUTABLE_CAST( TInt*, &Fields_CSD_WSP[KResourceID][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_WSP[KResourceID][0] ); + + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_CSD_WSP[KCompulsory][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_WSP[KCompulsory][0] ); + } + } + else + { + if ( iReqIpvType & EIPv6 ) + { + iField = (TApMember*) &Fields_CSD_IPv6[KApMember][0]; + iFieldCount = + sizeof( Fields_CSD_IPv6[KApMember] )/sizeof( TApMember ); + + iFieldAdvanced = + (TApMember*) &Fields_CSD_Advanced_IPv6[KApMember][0]; + iAdvancedFieldCount = + sizeof( Fields_CSD_Advanced_IPv6[KApMember] ) + / sizeof( TApMember ); + + iTitles = + MUTABLE_CAST( TInt*, + &Fields_CSD_IPv6[KResourceID][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_IPv6[KResourceID][0] ); + + iCompulsory = + MUTABLE_CAST( TInt*, + &Fields_CSD_IPv6[KCompulsory][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_CSD_Advanced_IPv6[KCompulsory][0] ); + } + else + { + iField = (TApMember*) &Fields_CSD[KApMember][0]; + iFieldCount = sizeof( Fields_CSD[KApMember] )/sizeof( TApMember ); + + iFieldAdvanced = (TApMember*) &Fields_CSD_Advanced[KApMember][0]; + iAdvancedFieldCount = + sizeof( Fields_CSD_Advanced[KApMember] )/sizeof( TApMember ); + + iTitles = MUTABLE_CAST( TInt*, &Fields_CSD[KResourceID][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, &Fields_CSD_Advanced[KResourceID][0] ); + + iCompulsory = MUTABLE_CAST( TInt*, &Fields_CSD[KCompulsory][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, &Fields_CSD_Advanced[KCompulsory][0] ); + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetCSDSettingArrays") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetGPRSSettingArrays +//---------------------------------------------------------- +// +void CApSettingsDlg::GetGPRSSettingArrays( TInt variant ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetGPRSSettingArrays") + + if ( variant & KWSPSettingsVisible ) + { + if ( iReqIpvType & EIPv6 ) + { + iField = ( TApMember* ) &Fields_GPRS_WSP_IPv6[ KApMember ][0]; + iFieldCount = sizeof( Fields_GPRS_WSP_IPv6[0] ) + / sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_GPRS_Advanced_WSP_IPv6[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_GPRS_Advanced_WSP_IPv6[ KApMember ]) + / sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_GPRS_WSP_IPv6[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( + TInt*, + &Fields_GPRS_Advanced_WSP_IPv6[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_GPRS_WSP_IPv6[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( + TInt*, + &Fields_GPRS_Advanced_WSP_IPv6[ KCompulsory ][0] ); + } + else + { + iField = ( TApMember* ) &Fields_GPRS_WSP[ KApMember ][0]; + iFieldCount = sizeof( Fields_GPRS_WSP[0] )/sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_GPRS_Advanced_WSP[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_GPRS_Advanced_WSP[ KApMember ]) + / sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_GPRS_WSP[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( + TInt*, + &Fields_GPRS_Advanced_WSP[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_GPRS_WSP[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( + TInt*, + &Fields_GPRS_Advanced_WSP[ KCompulsory ][0] ); + } + } + else + { + if ( iReqIpvType & EIPv6 ) + { + iField = ( TApMember* ) &Fields_GPRS_IPv6[ KApMember ][0]; + iFieldCount = sizeof( Fields_GPRS_IPv6[0] )/sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_GPRS_Advanced_IPv6[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_GPRS_Advanced_IPv6[ KApMember ]) + / sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_GPRS_IPv6[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_GPRS_Advanced_IPv6[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_GPRS_IPv6[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_GPRS_Advanced_IPv6[ KCompulsory ][0] ); + } + else + { + iField = ( TApMember* ) &Fields_GPRS[ KApMember ][0]; + iFieldCount = sizeof( Fields_GPRS[0] )/sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_GPRS_Advanced[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_GPRS_Advanced[ KApMember ])/sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_GPRS[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, &Fields_GPRS_Advanced[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_GPRS[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, &Fields_GPRS_Advanced[ KCompulsory ][0] ); + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetGPRSSettingArrays") + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetWLANSettingArraysL +//---------------------------------------------------------- +// +void CApSettingsDlg::GetWLANSettingArraysL( TInt /*aVariant*/ ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetWLANSettingArraysL") + + if ( IsWlanSupported() ) + { + // If IPv6 support requested, is the only place where L2 level needed, + // so it is the only place when it is variated... + if ( iReqIpvType & EIPv6 ) + { + if ( iL2Ipv4 ) + { + iFieldL2 = + (TApMember*) &Fields_WLAN_L2_IPv4[KApMember][0]; + iFieldCountL2 = + sizeof( Fields_WLAN_L2_IPv4[KApMember] ) + / sizeof( TApMember ); + iTitlesL2 = + MUTABLE_CAST( TInt*, + &Fields_WLAN_L2_IPv4[KResourceID][0] ); + iCompulsoryL2 = + MUTABLE_CAST( TInt*, + &Fields_WLAN_L2_IPv4[KCompulsory][0] ); + } + else + { + iFieldL2 = + (TApMember*) &Fields_CSD_L2_IPv6[KApMember][0]; + iFieldCountL2 = + sizeof( Fields_CSD_L2_IPv6[KApMember] ) + / sizeof( TApMember ); + iTitlesL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv6[KResourceID][0] ); + iCompulsoryL2 = + MUTABLE_CAST( TInt*, + &Fields_CSD_L2_IPv6[KCompulsory][0] ); + } + } + + + if ( iReqIpvType & EIPv6 ) + { + iField = ( TApMember* ) &Fields_WLAN_IPv6[ KApMember ][0]; + iFieldCount = sizeof( Fields_WLAN_IPv6[0] )/sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_WLAN_Advanced_IPv6[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_WLAN_Advanced_IPv6[ KApMember ]) + / sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_WLAN_IPv6[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_WLAN_Advanced_IPv6[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_WLAN_IPv6[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_WLAN_Advanced_IPv6[ KCompulsory ][0] ); + } + else + { + iField = ( TApMember* ) &Fields_WLAN_IPv4[ KApMember ][0]; + iFieldCount = sizeof( Fields_WLAN_IPv4[0] )/sizeof( TApMember ); + iFieldAdvanced = + ( TApMember* ) &Fields_WLAN_Advanced_IPv4[ KApMember ][0]; + iAdvancedFieldCount = + sizeof( Fields_WLAN_Advanced_IPv4[ KApMember ]) + / sizeof( TApMember ); + iTitles = + MUTABLE_CAST( TInt*, &Fields_WLAN_IPv4[ KResourceID ][0] ); + iTitlesAdvanced = + MUTABLE_CAST( TInt*, + &Fields_WLAN_Advanced_IPv4[ KResourceID ][0] ); + iCompulsory = + MUTABLE_CAST( TInt*, &Fields_WLAN_IPv4[ KCompulsory ][0] ); + iCompulsoryAdvanced = + MUTABLE_CAST( TInt*, + &Fields_WLAN_Advanced_IPv4[ KCompulsory ][0] ); + } + } + else + { + User::Leave( KErrNotSupported ); + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetWLANSettingArraysL") + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetNameServersL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetNameServersL( TBool aIp6 ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetNameServersL") + + TInt retval( 0 ); + + if ( (iReqIpvType & EIPv6) && aIp6 ) + { + retval = GetIpv6NameServerL(); + } + else + { + retval = GetIpv4NameServerL(); + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetNameServersL") + return retval; + } + + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::AddMenuListBoxItemL +//---------------------------------------------------------- +// +void CApSettingsDlg::AddMenuListBoxItemL( CDesCArrayFlat& aItemArray, + TApMember /*aMember*/, TInt aRes, + TInt aCompulsory ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::AddMenuListBoxItemL") + + // Define a heap descriptor to hold all the item text + // HBufC is non-modifiable + HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); + + // Define a heap descriptor to hold all the item text + TInt length = title->Length() + 10; + if ( aCompulsory ) + { + length += 3; + } + HBufC* itemText = HBufC::NewLC( length ); + + + // Define a modifiable pointer descriptor to be able to append text to the + // non-modifiable heap descriptor itemText + TPtr itemTextPtr = itemText->Des(); + itemTextPtr.Format( KTxtMenuListItemFormat, title ); + if ( aCompulsory ) + { + itemTextPtr.Append( KTxtCompulsory ); + } + + aItemArray.AppendL( *itemText ); + CleanupStack::PopAndDestroy( itemText ); + CleanupStack::PopAndDestroy( title ); // title + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddMenuListBoxItemL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::AskQueryIfWcdmaL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::AskQueryIfWcdmaL( TApMember aMember, TInt aCurrvalue ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::AskQueryIfWcdmaL") + + TBool accept = ETrue ; + TBool isWcdma = + FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); + if ( isWcdma && iBearerType == EApBearerTypeCSD && + aMember == EApIspBearerSpeed ) + { + TApCallSpeed newSpeed = GetBearerSpeedForSelection( aCurrvalue ); + switch ( newSpeed) + { + case KSpeed28800: + case KSpeed38400: + case KSpeed56000: + { + accept = AskQueryL( R_APUI_IAP_CONF_MAX_SPEED_WCDMA ); + break; + } + default: + { + break; + } + + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::AskQueryIfWcdmaL") + return accept; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetDomainNameServersTypeL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetDomainNameServersTypeL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetDomainNameServersTypeL") + + TInt retval( 0 ); + // GPRS, net type 4: + // if IspNameServ <> 0.0.0.0 => User defined + // GPRS, net type 6: + // if IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known + // CSD: + // if in IPv4settings: + // if IspNameServ <> 0.0.0.0 => User defined + // CSD: + // if in IPv6settings: + // if IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known + + if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) + { + TUint32 ipnettype( 0 ); + iApItem->ReadUint( EApGprsPdpType, ipnettype ); + if ( ipnettype == EIPv6 ) + { + retval = GetIPv6DNSTypeL(); + } + else + { + retval = GetIPv4DNSTypeL(); + } + } + else + { // CSD + // IPv4settings: IspNameServ <> 0.0.0.0 => User defined + // IPv6settings: + // IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known + if ( iL2Ipv4 ) + { // IPv4 settings + retval = GetIPv4DNSTypeL(); + } + else + { // IPv6 settings + retval = GetIPv6DNSTypeL(); + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetDomainNameServersTypeL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetIpv4NameServerL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetIpv4NameServerL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIpv4NameServerL") + + HBufC* dns1 = HBufC::NewLC( KModifiableTextLength ); + HBufC* dns2 = HBufC::NewLC( KModifiableTextLength ); + TPtr dns1ptr( dns1->Des() ); + TPtr dns2ptr( dns2->Des() ); + + TInt ResId( 0 ); + + iApItem->ReadTextL( EApGprsIPNameServer1, dns1ptr ); + iApItem->ReadTextL( EApGprsIPNameServer2, dns2ptr ); + ResId = R_DNSIP4_QUERY; + + TInetAddr dns1Addr; + TInetAddr dns2Addr; + dns1Addr.Input( dns1ptr ); + dns2Addr.Input( dns2ptr ); + + CAknMultiLineIpQueryDialog* ipquery = + CAknMultiLineIpQueryDialog::NewL( dns1Addr, dns2Addr ); + + TInt retval = ipquery->ExecuteLD( ResId ); + if ( retval ) + { + dns1Addr.Output( dns1ptr ); + dns2Addr.Output( dns2ptr ); + if ( dns1ptr.Compare( KDynIpAddress ) == 0 ) + { // move 2nd to first, set second to Dynamic... + iApItem->WriteTextL( EApGprsIPNameServer1, dns2ptr ); + iApItem->WriteTextL( EApGprsIPNameServer2, KDynIpAddress ); + } + else + { + iApItem->WriteTextL( EApGprsIPNameServer1, dns1ptr ); + iApItem->WriteTextL( EApGprsIPNameServer2, dns2ptr ); + } + } + CleanupStack::PopAndDestroy( 2 ); // dns1, dns2 + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIpv4NameServerL") + return retval; + } + + +//---------------------------------------------------------- +// CApSettingsDlg::GetIpv6NameServerL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetIpv6NameServerL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIpv6NameServerL") + + HBufC* dns1 = HBufC::NewLC( KModifiableTextLength ); + HBufC* dns2 = HBufC::NewLC( KModifiableTextLength ); + TPtr dns1ptr( dns1->Des() ); + TPtr dns2ptr( dns2->Des() ); + + TInt ResId( 0 ); + + iApItem->ReadTextL( EApIP6NameServer1, dns1ptr ); + iApItem->ReadTextL( EApIP6NameServer2, dns2ptr ); + ResId = R_DNSIP6_QUERY; + + if ( ( dns1ptr.Compare( KKnownNameServer1 ) == 0 ) + && ( dns2ptr.Compare( KKnownNameServer2 ) == 0 ) ) + { // special value, well-known + // in this case 'dynamic' string must be offered so + // temp data must be changed to 'dynamic' + dns1ptr = KDynIpv6Address; + dns2ptr = KDynIpv6Address; + } + + CApMultiLineDataQueryDialog* ipquery = + CApMultiLineDataQueryDialog::NewL( dns1ptr, dns2ptr ); + + TInt retval = ipquery->ExecuteLD( ResId ); + if ( retval ) + { + TInetAddr dns1Addr; + TInetAddr dns2Addr; + TInt err1( KErrNone ); + TInt err2( KErrNone ); + if ( dns1ptr.Compare( KEmpty ) != 0 ) + { + err1 = dns1Addr.Input( dns1ptr ); + } + if ( dns2ptr.Compare( KEmpty ) != 0 ) + { + err2 = dns2Addr.Input( dns2ptr ); + } + if ( err1 || err2 ) + { + ShowNoteL( R_APUI_VIEW_SET_INFO_INVALID_IP ); + GetIpv6NameServerL(); + } + else + { + if ( + ( dns1ptr.Compare( KDynIpv6Address ) == 0 ) || + ( dns1ptr.Compare( KEmpty ) == 0 ) + ) + { // swap them: move 2nd to first, set second to Dynamic... + iApItem->WriteTextL( EApIP6NameServer1, dns2ptr ); + iApItem->WriteTextL( EApIP6NameServer2, KDynIpv6Address ); + } + else + { // keep the original order + iApItem->WriteTextL( EApIP6NameServer1, dns1ptr ); + iApItem->WriteTextL( EApIP6NameServer2, dns2ptr ); + } + } + } + CleanupStack::PopAndDestroy( 2 ); // dns1, dns2 + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIpv6NameServerL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetIPv6DNSTypeL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetIPv6DNSTypeL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIPv6DNSTypeL") + + TInt retval( 0 ); + + HBufC* buf1 = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr1( buf1->Des() ); + + HBufC* buf2 = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr2( buf2->Des() ); + + // net type 6: if IspIPv6NameServ <> 0.0.0.0 + // => User defined OR well-known + iApItem->ReadTextL( EApIP6NameServer1, ptr1 ); + iApItem->ReadTextL( EApIP6NameServer2, ptr2 ); + + if ( ( ptr1.Compare( KKnownNameServer1 ) == 0 ) + && ( ptr2.Compare( KKnownNameServer2 ) == 0 ) ) + { // special value, well-known + retval = 1; + } + else + { + // dynamic, if 0:0:... + // OR EMPTY text... + if ( ( ( ptr1.Compare( KDynIpv6Address ) == 0 ) + || ( ptr1.Compare( KEmpty ) == 0 ) ) + &&( ( ptr2.Compare( KDynIpv6Address ) == 0 ) + ||( ptr2.Compare( KEmpty ) == 0 ) ) ) + { // dynamic, 0:0:... + // OR in case of CSD, HSCSD, it might be user defined, + // as for those bearers Dynamic is not possible... + TApBearerType bt = iApItem->BearerTypeL(); + switch (bt) + { + case EApBearerTypeCSD: + case EApBearerTypeHSCSD: + { + retval = 2; // consider it user defined + break; + } + default: + { + retval = 0; + break; + } + } + } + else + { // other value, user defined + retval = 2; + } + } + + CleanupStack::PopAndDestroy( 2 ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIPv6DNSTypeL") + return retval; + } + + + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetIPv4DNSTypeL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::GetIPv4DNSTypeL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIPv4DNSTypeL") + + TInt retval( 0 ); + + HBufC* buf1 = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr1( buf1->Des() ); + + HBufC* buf2 = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr2( buf2->Des() ); + + // net type 4: if IspNameServ <> 0.0.0.0 => User defined + iApItem->ReadTextL( EApGprsIPNameServer1, ptr1 ); + iApItem->ReadTextL( EApGprsIPNameServer2, ptr2 ); + + if ( ( ptr1.Compare( KDynIpAddress ) == 0 ) + && ( ptr2.Compare( KDynIpAddress ) == 0 ) ) + { // dynamic, 0:0:... + retval = 0; + } + else + { // other value, user defined + retval = 2; + } + + CleanupStack::PopAndDestroy( 2 ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIPv4DNSTypeL") + return retval; + } + + + + + +// --------------------------------------------------------- +// CApSettingsDlg::StripNonNumberLC +// --------------------------------------------------------- +// +HBufC* CApSettingsDlg::StripNonNumberLC( const TDesC16& aInText ) + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::StripNonNumberLC") + +// CLOG( ( EApItem, 0, _L( "-> CApSettingsDlg::StripNonNumberLC" ) ) ); + + TInt size = aInText.Length(); + HBufC* aOutText = HBufC::NewLC( size ); + TPtr ptr = aOutText->Des(); + + for ( TInt ii=0; ii* bearerlist = + new(ELeave) CArrayFixFlat(4); + CleanupStack::PushL( bearerlist ); + + bearerlist->AppendL( EApBearerTypeGPRS ); + + if ( IsWlanSupported() ) + { + bearerlist->AppendL( EApBearerTypeWLAN ); + } + + TBool isCsdSupported = + FeatureManager::FeatureSupported( KFeatureIdAppCsdSupport ); + if ( isCsdSupported ) + { + bearerlist->AppendL( EApBearerTypeCSD ); + } + if ( IsHSCSDEnabledL() && isCsdSupported ) + { + bearerlist->AppendL( EApBearerTypeHSCSD ); + } + + __ASSERT_DEBUG( ( aPos < bearerlist->Count() ), \ + Panic( EInvalidBearerType ) ); + __ASSERT_DEBUG( ( aPos >= 0 ), Panic( EInvalidBearerType ) ); + + aPos = Max( aPos, 0 ); + aPos = Min( aPos, ( bearerlist->Count() - 1 ) ); + + bearer = bearerlist->At( aPos ); + + CleanupStack::PopAndDestroy( bearerlist ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::BearerItemPos2BearerTypeL") + return bearer; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::ChangeWlanNetworkNameL +//---------------------------------------------------------- +// +void CApSettingsDlg::ChangeWlanNetworkNameL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWlanNetworkNameL") + + // Implement WLAN network name change + TInt currvalue( 0 ); + CDesCArrayFlat* items = FillPopupSettingPageLC( EApWlanNetworkName, + currvalue ); + + TInt attr_resid( 0 ); + GetResId( EApWlanNetworkName, attr_resid ); + HBufC* titlebuf; + CAknRadioButtonSettingPage* dlg; + if ( attr_resid ) + { + titlebuf = iEikonEnv->AllocReadResourceLC( attr_resid ); + dlg = new ( ELeave )CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE, + currvalue, items ); + // must push 'cause SetSettingTextL can leave... + CleanupStack::PushL( dlg ); + TPtrC ptr( titlebuf->Des() ); + dlg->SetSettingTextL( ptr ); + CleanupStack::Pop(); // dlg + } + else + { + dlg = new ( ELeave )CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE, currvalue, items ); + } + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) + { + if ( !currvalue ) + {// user defined + QueryWlanNetworkNameL(); + } + else + { // scan for, select one! + CConnectionUiUtilities* connUiUtils = + CConnectionUiUtilities::NewL(); + CleanupStack::PushL( connUiUtils ); + + TWlanSsid ssid; + TWlanConnectionMode connmode; + TWlanConnectionSecurityMode secmode; + TBool ret = connUiUtils->SearchWLANNetwork( ssid, + connmode, + secmode ); + if ( ret ) + { + HBufC* tmp = HBufC::NewLC( KCommsDbSvrMaxFieldLength ); + TPtr16 tmpPtr16 = tmp->Des(); + CnvUtfConverter::ConvertToUnicodeFromUtf8( tmpPtr16, ssid); + + iApItem->WriteTextL( EApWlanNetworkName, *tmp ); + CleanupStack::PopAndDestroy( tmp ); + // now handle connmode & secmode settings + if ( connmode == EWlanConnectionModeInfrastructure ) + { + iApItem->WriteUint( EApWlanNetworkMode, EInfra ); + } + else + { + if ( connmode == EWlanConnectionModeAdhoc ) + { + iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); + } + else + { + User::Leave( KErrNotSupported ); + } + } + switch (secmode) + { + case EWlanConnectionSecurityOpen: + { + iApItem->WriteUint( EApWlanSecurityMode, EOpen ); + break; + } + case EWlanConnectionSecurityWep: + { + iApItem->WriteUint( EApWlanSecurityMode, EWep ); + break; + } + case EWlanConnectionSecurity802d1x: + { + iApItem->WriteUint( EApWlanSecurityMode, E802_1x ); + break; + } + case EWlanConnectionSecurityWpa: + { + iApItem->WriteUint( EApWlanSecurityMode, EWpa ); + break; + } + case EWlanConnectionSecurityWpaPsk: + { + iApItem->WriteUint( EApWlanSecurityMode, EWpa ); + break; + } + default: + { + break; + } + } + + } + CleanupStack::PopAndDestroy( connUiUtils ); + } + } + if ( attr_resid ) + { + // titlebuf, text title readed from resource... + CleanupStack::PopAndDestroy(); + } + // items, will also delete all elements in the array! + CleanupStack::PopAndDestroy( items ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeWlanNetworkNameL") + } + + +//---------------------------------------------------------- +// CApSettingsDlg::ChangeWlanSecuritySettings +//---------------------------------------------------------- +// +TInt CApSettingsDlg::ChangeWlanSecuritySettingsL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWlanSecuritySettingsL") + + TInt retval(0); + TUint32 secmode( 0 ); + iApItem->ReadUint( EApWlanSecurityMode, secmode ); + + TBool need2changeid( EFalse ); + TUint32 origServiceId(0); + iApItem->ReadUint( EApIapServiceId, origServiceId ); + if ( iOriginalBearerType != iApItem->BearerTypeL() ) + { + need2changeid = ETrue; + iApItem->WriteUint( EApIapServiceId, 0 ); + } + + switch ( secmode ) + { + case EOpen: + { + ShowNoteL( R_APUI_VIEW_NO_SECURITY_SETTINGS ); + break; + } + case EWep: + { + retval = ChangeWepSecuritySettingsL(); + break; + } + case E802_1x: + { + retval = Change8021xSecuritySettingsL(); + break; + } + case EWpa: + case EWpa2: + { + retval = ChangeWpaSecuritySettingsL(); + break; + } + default: + { + // some weird error, repair it... + __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); + break; + } + } + if ( need2changeid ) + { + iApItem->WriteUint( EApIapServiceId, origServiceId ); + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeWlanSecuritySettingsL") + return retval; + } + + +//---------------------------------------------------------- +// CApSettingsDlg::ChangeWepSecuritySettingsL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::ChangeWepSecuritySettingsL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWepSecuritySettingsL<->") + + return iHandler->iModel->ChangeWepSettingsL( iApItem ); + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::ChangeWpaSecuritySettingsL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::ChangeWpaSecuritySettingsL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWpaSecuritySettingsL<->") + + return iHandler->iModel->ChangeWpaSettingsL( iApItem ); + } + + +//---------------------------------------------------------- +// CApSettingsDlg::Change8021xSecuritySettingsL +//---------------------------------------------------------- +// +TInt CApSettingsDlg::Change8021xSecuritySettingsL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::Change8021xSecuritySettingsL<->") + + return iHandler->iModel->Change8021xSettingsL( iApItem ); + } + + + + +//---------------------------------------------------------- +// CApSettingsDlg::IsWlanSupported +//---------------------------------------------------------- +// +TBool CApSettingsDlg::IsWlanSupported() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::IsWlanSupported") + + TBool retval = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ); +#ifdef __TEST_WLAN_SUPPORT + retval = ETrue; +#endif // __TEST_WLAN_SUPPORT + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsWlanSupported") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::QueryWlanNetworkNameL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::QueryWlanNetworkNameL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::QueryWlanNetworkNameL") + + TBool retval( EFalse ); + + HBufC* buff = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( buff->Des() ); + iApItem->ReadTextL( EApWlanNetworkName, ptr ); + + CAknQueryDialog* dlg = + CAknQueryDialog::NewL( ptr, CAknQueryDialog::ENoTone ); + + if ( dlg->ExecuteLD( R_APUI_WLAN_NAME_QUERY ) ) + { + iApItem->WriteTextL( EApWlanNetworkName, ptr ); + retval = ETrue; + } + CleanupStack::PopAndDestroy( buff ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::QueryWlanNetworkNameL") + return retval; + } + + +//---------------------------------------------------------- +// CApSettingsDlg::IsNetMaskAndGatewayVisible +//---------------------------------------------------------- +// +TBool CApSettingsDlg::IsNetMaskAndGatewayVisibleL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::IsNetMaskAndGatewayVisibleL") + + TBool retval(EFalse); + // display only if: + // Phone IP Addr. <> Automatic (0.0.0.0) + HBufC* tmpValue = HBufC::NewLC( KModifiableTextLength ); + TPtr ptr( tmpValue->Des() ); + iApItem->ReadTextL( EApIspIPAddr, ptr ); + if ( ( tmpValue->Compare( KDynIpAddress ) != 0 ) + && ( tmpValue->Compare( KEmptyText ) != 0 ) ) + { + retval = ETrue; + } + CleanupStack::PopAndDestroy( tmpValue ); + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsNetMaskAndGatewayVisibleL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::GetAdHocChannelL +//---------------------------------------------------------- +// +TUint32 CApSettingsDlg::GetAdHocChannelL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::GetAdHocChannelL") + + // Get real ad-hoc channel + // Default: KDefAdhocChannel + TInt channel( KDefAdhocChannel ); + TUint32 retval(0); + iApItem->ReadUint( EApWlanChannelId, retval ); + channel = TInt(retval); + if ( !channel ) + { + channel = KDefAdhocChannel; + } + + CAknNumberQueryDialog* dlg = + CAknNumberQueryDialog::NewL( channel, CAknQueryDialog::ENoTone ); + + if ( dlg->ExecuteLD( R_APUI_WLAN_ADHOC_CHANNEL_QUERY ) ) + { + retval = channel; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetAdHocChannelL") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::IsAdhocChannelVisible +//---------------------------------------------------------- +// +TBool CApSettingsDlg::IsAdhocChannelVisible() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::IsAdhocChannelVisible") + + TBool retval(EFalse); + TUint32 netmode( 0 ); + iApItem->ReadUint( EApWlanNetworkMode, netmode ); + if ( netmode == EAdhoc ) + { + retval = ETrue; + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsAdhocChannelVisible") + return retval; + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::HasSecuritySettingsFilledL +//---------------------------------------------------------- +// +TBool CApSettingsDlg::HasSecuritySettingsFilledL() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::HasSecuritySettingsFilledL<->") + + return iDataModel->HasWlanSecSettingsFilledL( *iApItem ); + } + + + +//---------------------------------------------------------- +// CApSettingsDlg::LimitSecMode +//---------------------------------------------------------- +// +void CApSettingsDlg::LimitSecMode() + { + APSETUILOGGER_ENTERFN( ESettings,"Settings::LimitSecMode") + + TUint32 secmode( 0 ); + iApItem->ReadUint( EApWlanSecurityMode, secmode ); + switch ( secmode ) + { + case EOpen: + case EWep: + // nothing to do in this case + { + break; + } + case E802_1x: + case EWpa: + case EWpa2: + default: + { + iApItem->WriteUint( EApWlanSecurityMode, EOpen ); + break; + } + } + + APSETUILOGGER_LEAVEFN( ESettings,"Settings::LimitSecMode") + } + + + + +// --------------------------------------------------------- +// CApSettingsDlg::CanSaveWlanCompulsoriesL( ) +// --------------------------------------------------------- +// +CApSettingsDlg::TSaveAction CApSettingsDlg::CanSaveWlanCompulsoriesL( + TApMember& aDataNeeded ) + { + TSaveAction retval( EApCanSave ); + + HBufC *sgd = HBufC::NewLC( KModifiableTextLength ); + TPtr16 ptr( sgd->Des() ); + + if ( (retval != EApShallGoBack) && (retval != EApMustDelete) + && IsNetMaskAndGatewayVisibleL() ) + { // now check compulsory fields + iApItem->ReadTextL( EApWlanIpNetMask, ptr ); + if ( ( ptr.Compare( KDynIpAddress ) == 0 ) + || ( ptr.Compare( KEmptyText ) == 0 ) ) + { + retval = EApShallGoBack; + aDataNeeded = EApWlanIpNetMask; + if ( AskQueryL( + R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) ) + { + retval = EApMustDelete; + } + } + else + { + iApItem->ReadTextL( EApIspIPGateway, ptr ); + if ( ( sgd->Compare( KDynIpAddress ) == 0 ) + || ( sgd->Compare( KEmptyText ) == 0 ) ) + { + retval = EApShallGoBack; + aDataNeeded = EApIspIPGateway; + if ( AskQueryL( + R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) + ) + { + retval = EApMustDelete; + } + } + } + } + CleanupStack::PopAndDestroy( sgd ); // sgd + + return retval; + } + + +// --------------------------------------------------------- +// CApSettingsDlg::RestoreIpv4SettingsL() +// --------------------------------------------------------- +// +void CApSettingsDlg::RestoreIpv4SettingsL() + { + HBufC* buf = HBufC::NewLC( KModifiableTextLength ); + TPtr ptr( buf->Des() ); + + iBackupApItem->ReadTextL( EApIspIPAddr, ptr ); + iApItem->WriteTextL( EApIspIPAddr, ptr ); + + iBackupApItem->ReadTextL( EApIspIPNetMask, ptr ); + iApItem->WriteTextL( EApIspIPNetMask, ptr ); + + iBackupApItem->ReadTextL( EApIspIPGateway, ptr ); + iApItem->WriteTextL( EApIspIPGateway, ptr ); + + iBackupApItem->ReadTextL( EApIspIPNameServer1, ptr ); + iApItem->WriteTextL( EApIspIPNameServer1, ptr ); + + iBackupApItem->ReadTextL( EApIspIPNameServer2, ptr ); + iApItem->WriteTextL( EApIspIPNameServer2, ptr ); + + CleanupStack::PopAndDestroy( buf ); + + } + + + +// End of File