|
1 /* |
|
2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * Defines dialog for access point view/edit. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include "APSettingsHandlerUIVariant.hrh" |
|
22 |
|
23 |
|
24 #include <aknnavide.h> |
|
25 #include <akntitle.h> |
|
26 #include <AknQueryDialog.h> |
|
27 #include <akntextsettingpage.h> |
|
28 #include <aknpopupsettingpage.h> |
|
29 #include <aknradiobuttonsettingpage.h> |
|
30 #include <aknpasswordsettingpage.h> |
|
31 #include <aknmfnesettingpage.h> |
|
32 |
|
33 #include <ApAccessPointItem.h> |
|
34 #include <utf.h> |
|
35 |
|
36 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
37 #include <nifvar_internal.h> |
|
38 #endif |
|
39 |
|
40 |
|
41 #include "ApSettingsLookups.h" |
|
42 #include "ApSettingsDlg.h" |
|
43 #include "ApSettingsModel.h" |
|
44 #include <ApSetUI.rsg> |
|
45 |
|
46 #include <csxhelp/cp.hlp.hrh> |
|
47 |
|
48 #include "ApSettingsHandlerUI.hrh" |
|
49 #include "ApsettingshandleruiImpl.h" |
|
50 #include "ApSettingsHandlerConsts.h" |
|
51 #include <ApSettingsHandlerCommons.h> |
|
52 |
|
53 #include "ApSettingsHandlerLogger.h" |
|
54 |
|
55 #include <commonphoneparser.h> |
|
56 |
|
57 #include "ApNetSelPopupList.h" |
|
58 |
|
59 #include "AccessPointTextSettingPage.h" |
|
60 |
|
61 |
|
62 #include <featmgr.h> |
|
63 |
|
64 #include "FeatureManagerWrapper.h" |
|
65 #include "ApMultiLineDataQueryDialog.h" |
|
66 |
|
67 #include <ConnectionUiUtilities.h> |
|
68 #include <wlanmgmtcommon.h> |
|
69 #include <centralrepository.h> |
|
70 |
|
71 // CONSTANTS |
|
72 // General Settings UID, Hardcoded |
|
73 // const TUid KGeneralSettingsUid={0X100058EC}; |
|
74 // const TInt KOptionalDefaultValue = 1; |
|
75 |
|
76 |
|
77 |
|
78 const TInt KIspCallAnalogue = 0; |
|
79 const TInt KIspCallIsdn110 = 1; |
|
80 const TInt KIspCallIsdn120 = 2; |
|
81 |
|
82 const TInt KBearerListGprs = 0; |
|
83 const TInt KBearerListWLAN = 1; |
|
84 const TInt KBearerListCSD = 2; |
|
85 const TInt KBearerListHSCSD = 3; |
|
86 |
|
87 |
|
88 |
|
89 // They provide the indexes. |
|
90 const TInt KBearerArrayCSD = 0; |
|
91 const TInt KBearerArrayGPRS = 1; |
|
92 const TInt KBearerArrayHSCSD = 2; |
|
93 const TInt KBearerArrayWLAN = 3; |
|
94 |
|
95 const TInt KBoolMaxNumber = 1; |
|
96 |
|
97 _LIT( KEmptyText, "" ); |
|
98 _LIT( KTxtListItemFormat, " \t%S\t\t%S" ); |
|
99 _LIT( KTxtMenuListItemFormat, " \t%S\t\t" ); |
|
100 _LIT( KTxtCompulsory, "\t*" ); |
|
101 |
|
102 _LIT( KTxtNumber, "%d" ); |
|
103 |
|
104 |
|
105 _LIT( KKnownNameServer1, "fec0:000:0000:ffff::1" ); |
|
106 _LIT( KKnownNameServer2, "fec0:000:0000:ffff::2" ); |
|
107 |
|
108 |
|
109 const TInt KStaredPasswordLength = 4; |
|
110 |
|
111 const TUint32 KDefAdhocChannel = 7; |
|
112 |
|
113 |
|
114 const TInt KItemIndex0 = 0; |
|
115 const TInt KItemIndex1 = 1; |
|
116 const TInt KItemIndex2 = 2; |
|
117 const TInt KItemIndex3 = 3; |
|
118 |
|
119 // ================= MEMBER FUNCTIONS ======================= |
|
120 // --------------------------------------------------------- |
|
121 // CApSettingsDlg::ConstructAndRunLD |
|
122 // Constructs the dialog and runs it. |
|
123 // --------------------------------------------------------- |
|
124 // |
|
125 TInt CApSettingsDlg::ConstructAndRunLD( CApSettingsModel& aModel, |
|
126 CApSettingsHandlerImpl& aHandler, |
|
127 TUint32& aUid, |
|
128 CApAccessPointItem* aItem ) |
|
129 { |
|
130 APSETUILOGGER_ENTERFN( ESettings,"Settings::ConstructAndRunLD") |
|
131 |
|
132 CleanupStack::PushL( this ); |
|
133 |
|
134 iFeatureManagerWrapper = CFeatureManagerWrapper::NewL(); |
|
135 |
|
136 iHelpSupported = FeatureManager::FeatureSupported( KFeatureIdHelp ); |
|
137 |
|
138 #ifdef __TEST_OOMDEBUG |
|
139 RFs fs; |
|
140 User::LeaveIfError( fs.Connect() ); |
|
141 CleanupClosePushL<RFs>( fs ); |
|
142 TUint att; |
|
143 if ( fs.Att( KTestFileName, att ) == KErrNone ) |
|
144 { |
|
145 iMemTestOn = ETrue; |
|
146 } |
|
147 else |
|
148 { |
|
149 iMemTestOn = EFalse; |
|
150 } |
|
151 CleanupStack::PopAndDestroy(); // fs, will also close it |
|
152 #endif // __TEST_OOMDEBUG |
|
153 |
|
154 |
|
155 iUid = &aUid; |
|
156 |
|
157 iDataModel = &aModel; |
|
158 iHandler = &aHandler; |
|
159 iVariant = iHandler->iExt->iVariant; |
|
160 |
|
161 |
|
162 CApAccessPointItem* ap = CApAccessPointItem::NewLC(); |
|
163 |
|
164 iBearerItemArray = |
|
165 new( ELeave )CArrayPtrFlat<CApAccessPointItem>( KBearers ); |
|
166 iBearerItemArray->ResetAndDestroy(); |
|
167 for ( TInt i=0; i<KBearers; i++ ) |
|
168 { |
|
169 iBearerItemArray->AppendL( NULL ); |
|
170 } |
|
171 TApBearerType ab = ap->BearerTypeL(); |
|
172 iBearerItemArray->At( BearerToArrayIndexL( ab ) ) = ap; |
|
173 // Now iApItem is part of array-> destructed member var, pop it. |
|
174 CleanupStack::Pop( ap ); |
|
175 |
|
176 iApItem = ap; |
|
177 |
|
178 if ( !aItem ) |
|
179 { |
|
180 iDataModel->AccessPointDataL( *iUid, *iApItem ); |
|
181 } |
|
182 else |
|
183 { |
|
184 iApItem->CopyFromL( *aItem ); |
|
185 } |
|
186 iDataModel->ClearWEPAndWPASettings(); |
|
187 |
|
188 iOldApItem = CApAccessPointItem::NewLC(); |
|
189 CleanupStack::Pop(); // member var |
|
190 |
|
191 iOldApItem->CopyFromL( *iApItem ); |
|
192 |
|
193 iOriginalBearerType = iApItem->BearerTypeL(); |
|
194 |
|
195 ConstructL( R_APSETTINGS_MENUBAR ); |
|
196 |
|
197 SetBearerTypeL( iApItem->BearerTypeL() ); |
|
198 // ExecuteLD will PushL( this ), so we have to Pop it... |
|
199 CleanupStack::Pop(); // this |
|
200 |
|
201 |
|
202 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ConstructAndRunLD") |
|
203 return ExecuteLD( R_APSETTINGS_DIALOG ); |
|
204 } |
|
205 |
|
206 |
|
207 |
|
208 // Destructor |
|
209 CApSettingsDlg::~CApSettingsDlg() |
|
210 { |
|
211 APSETUILOGGER_ENTERFN( ESettings,"Settings::~CApSettingsDlg") |
|
212 |
|
213 delete iFeatureManagerWrapper; |
|
214 |
|
215 if ( iDataModel ) |
|
216 {// Remove ourselves from observers... |
|
217 iDataModel->Database()->RemoveObserver( this ); |
|
218 } |
|
219 |
|
220 if ( iOldApItem ) |
|
221 { |
|
222 delete iOldApItem; |
|
223 } |
|
224 |
|
225 if ( iNaviDecorator ) |
|
226 { |
|
227 delete iNaviDecorator; |
|
228 } |
|
229 |
|
230 if ( iTitlePane ) |
|
231 { |
|
232 // set old text back, if we have it... |
|
233 if ( iOldTitleText ) |
|
234 { |
|
235 if ( iExitReason != EShutDown ) |
|
236 { |
|
237 TRAP_IGNORE( iTitlePane->SetTextL( *iOldTitleText ) ); |
|
238 } |
|
239 delete iOldTitleText; |
|
240 } |
|
241 } |
|
242 |
|
243 if ( iBearerItemArray ) |
|
244 { |
|
245 iBearerItemArray->ResetAndDestroy(); |
|
246 delete iBearerItemArray; |
|
247 } |
|
248 |
|
249 if (iBackupApItem) |
|
250 { |
|
251 delete iBackupApItem; |
|
252 } |
|
253 |
|
254 APSETUILOGGER_LEAVEFN( ESettings,"Settings::~CApSettingsDlg") |
|
255 } |
|
256 |
|
257 |
|
258 |
|
259 // --------------------------------------------------------- |
|
260 // CApSettingsDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent, |
|
261 // TEventCode aType ) |
|
262 // Handles key events |
|
263 // --------------------------------------------------------- |
|
264 // |
|
265 TKeyResponse CApSettingsDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent, |
|
266 TEventCode aType ) |
|
267 { |
|
268 APSETUILOGGER_ENTERFN( ESettings,"Settings::OfferKeyEventL") |
|
269 |
|
270 TKeyResponse retval( EKeyWasNotConsumed ); |
|
271 // Only interested in standard key events |
|
272 if ( aType == EEventKey ) |
|
273 { |
|
274 // If a menu is showing offer key events to it. |
|
275 if ( CAknDialog::MenuShowing() ) |
|
276 { |
|
277 retval = CAknDialog::OfferKeyEventL( aKeyEvent, aType ); |
|
278 } |
|
279 else |
|
280 { |
|
281 if ( iList ) |
|
282 { |
|
283 // as list IS consuming, must handle because it |
|
284 // IS the SHUTDOWN... |
|
285 // or, a view switch is shutting us down... |
|
286 if ( aKeyEvent.iCode == EKeyEscape ) |
|
287 { |
|
288 ProcessCommandL( EEikCmdExit ); |
|
289 retval = EKeyWasConsumed; |
|
290 } |
|
291 else |
|
292 { |
|
293 retval = iList->OfferKeyEventL( aKeyEvent, aType ); |
|
294 if ( iSecSettingsExitReason ) |
|
295 { |
|
296 if ( iSecSettingsExitReason |
|
297 & KApUiEventShutDownRequested ) |
|
298 { |
|
299 ProcessCommandL( EAknCmdExit ); |
|
300 } |
|
301 else |
|
302 { |
|
303 if ( iSecSettingsExitReason |
|
304 & KApUiEventExitRequested ) |
|
305 { |
|
306 ProcessCommandL( EApSelCmdExit ); |
|
307 } |
|
308 } |
|
309 } |
|
310 } |
|
311 } |
|
312 else |
|
313 { |
|
314 if ( aKeyEvent.iCode == EKeyOK ) |
|
315 { |
|
316 ProcessCommandL( EApSelCmdChange ); |
|
317 retval = EKeyWasConsumed; |
|
318 } |
|
319 } |
|
320 } |
|
321 } |
|
322 |
|
323 APSETUILOGGER_LEAVEFN( ESettings,"Settings::OfferKeyEventL") |
|
324 return retval; |
|
325 } |
|
326 |
|
327 |
|
328 |
|
329 // --------------------------------------------------------- |
|
330 // CApSettingsDlg::NewL |
|
331 // Two-phase dconstructor, second phase is ConstructAndRunLD |
|
332 // --------------------------------------------------------- |
|
333 // |
|
334 CApSettingsDlg* CApSettingsDlg::NewL( TInt aIspFilter, |
|
335 TInt aBearerFilter, |
|
336 TInt aSortType, |
|
337 TUint32& aEventStore, |
|
338 TInt aReqIpvType |
|
339 ) |
|
340 { |
|
341 APSETUILOGGER_ENTERFN( ESettings,"Settings::NewL") |
|
342 |
|
343 CApSettingsDlg* db = |
|
344 new ( ELeave )CApSettingsDlg( aIspFilter, |
|
345 aBearerFilter, |
|
346 aSortType, |
|
347 aEventStore, |
|
348 aReqIpvType |
|
349 ); |
|
350 |
|
351 APSETUILOGGER_LEAVEFN( ESettings,"Settings::NewL") |
|
352 return db; |
|
353 |
|
354 } |
|
355 |
|
356 |
|
357 |
|
358 |
|
359 // Constructor |
|
360 CApSettingsDlg::CApSettingsDlg( TInt aIspFilter, TInt aBearerFilter, |
|
361 TInt aSortType, TUint32& aEventStore, |
|
362 TInt aReqIpvType ) |
|
363 : |
|
364 iLevel( 0 ), |
|
365 iOldIndex( 0 ), |
|
366 iOldTopIndex( 0 ), |
|
367 iAdvIndex( 0 ), |
|
368 iBearerType( EApBearerTypeAll ), |
|
369 iIspFilter( aIspFilter ), |
|
370 iBearerFilter( aBearerFilter ), |
|
371 iSortType( aSortType ), |
|
372 iEventStore( &aEventStore ), |
|
373 iFieldCount( 0 ), |
|
374 iAdvancedFieldCount( 0 ), |
|
375 iExitReason( EExitNone ), |
|
376 iReqIpvType( aReqIpvType ), |
|
377 iL2Ipv4( ETrue ), |
|
378 iSecSettingsExitReason(0) |
|
379 { |
|
380 iBackupApItem = NULL; |
|
381 } |
|
382 |
|
383 |
|
384 // --------------------------------------------------------- |
|
385 // CApSettingsDlg::OkToExitL( TInt aButtonId) |
|
386 // called by framework when the OK button is pressed |
|
387 // --------------------------------------------------------- |
|
388 // |
|
389 TBool CApSettingsDlg::OkToExitL( TInt aButtonId ) |
|
390 { |
|
391 APSETUILOGGER_ENTERFN( ESettings,"Settings::OkToExitL") |
|
392 |
|
393 // Translate the button presses into commands for the appui & current |
|
394 // view to handle |
|
395 TBool retval( EFalse ); |
|
396 if ( aButtonId == EAknSoftkeyOptions ) |
|
397 { |
|
398 DisplayMenuL() ; |
|
399 } |
|
400 else |
|
401 { |
|
402 if ( (aButtonId == EApSelCmdChange) |
|
403 || (aButtonId == EApSelCmdQuickChange)) |
|
404 { |
|
405 ProcessCommandL(aButtonId); |
|
406 if ( iSecSettingsExitReason ) |
|
407 { |
|
408 if ( iSecSettingsExitReason |
|
409 & KApUiEventShutDownRequested ) |
|
410 { |
|
411 ProcessCommandL( EAknCmdExit ); |
|
412 // retval = ETrue; // exit the dialog |
|
413 } |
|
414 else |
|
415 { |
|
416 if ( iSecSettingsExitReason |
|
417 & KApUiEventExitRequested ) |
|
418 { |
|
419 ProcessCommandL( EApSelCmdExit ); |
|
420 // retval = ETrue; // exit the dialog |
|
421 } |
|
422 } |
|
423 } |
|
424 } |
|
425 else |
|
426 { |
|
427 if ( aButtonId == EAknSoftkeyBack ) |
|
428 { |
|
429 if ( iLevel ) |
|
430 { |
|
431 TSaveAction cansave( EApNoAction ); |
|
432 if ( iLevel == 2 ) |
|
433 {// coming back from Ipv4 settings |
|
434 // check if Wlan and has compulsory fields |
|
435 if (iBearerType == EApBearerTypeWLAN) |
|
436 { // WLAN |
|
437 TApMember member; |
|
438 cansave = CanSaveWlanCompulsoriesL( member ); |
|
439 switch (cansave) |
|
440 { |
|
441 case EApCanSave: |
|
442 { |
|
443 // nothing to do in this case, simply go on. |
|
444 iLevel --; |
|
445 break; |
|
446 } |
|
447 case EApMustDelete: |
|
448 { |
|
449 // user said quit without save, |
|
450 // restore from iBackupApItem |
|
451 RestoreIpv4SettingsL(); |
|
452 iLevel --; |
|
453 break; |
|
454 } |
|
455 case EApShallGoBack: |
|
456 { |
|
457 // user wants to re-edit, do not come back... |
|
458 // no change in iLevel |
|
459 |
|
460 // Set correct item to edit |
|
461 switch ( member ) |
|
462 { |
|
463 case EApWlanIpNetMask: |
|
464 case EApIspIPNetMask: |
|
465 { |
|
466 if ( IsWlanSupported() ) |
|
467 { |
|
468 SelectItem( KListIndexWLANSubnetMask ); |
|
469 retval = EFalse; |
|
470 } |
|
471 else |
|
472 { |
|
473 User::Leave( KErrNotSupported ); |
|
474 } |
|
475 break; |
|
476 } |
|
477 case EApIspIPGateway: |
|
478 case EApWlanIpGateway: |
|
479 { |
|
480 if ( IsWlanSupported() ) |
|
481 { |
|
482 SelectItem( KListIndexWLANDefaultGateway ); |
|
483 retval = EFalse; |
|
484 } |
|
485 else |
|
486 { |
|
487 User::Leave( KErrNotSupported ); |
|
488 } |
|
489 break; |
|
490 } |
|
491 default: |
|
492 {// otherwise, nothing to do... |
|
493 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
494 break; |
|
495 } |
|
496 } |
|
497 break; |
|
498 } |
|
499 case EApNoAction: |
|
500 default: |
|
501 { |
|
502 // this is not a valid case as it always one from |
|
503 // the above 3, |
|
504 // nothing to do, |
|
505 iLevel --; |
|
506 break; |
|
507 } |
|
508 } |
|
509 } |
|
510 else |
|
511 { |
|
512 iLevel--; |
|
513 } |
|
514 } |
|
515 else |
|
516 { |
|
517 iLevel--; |
|
518 } |
|
519 HandleListboxDataChangeL( EFalse ); |
|
520 if ( iOldIndex >=0 ) |
|
521 { |
|
522 if ( cansave != EApShallGoBack ) |
|
523 { |
|
524 iList->SetTopItemIndex( iOldTopIndex ); |
|
525 iList->SetCurrentItemIndexAndDraw( iOldIndex ); |
|
526 } |
|
527 if ( *iEventStore & KApUiEventExitRequested ) |
|
528 { |
|
529 ProcessCommandL( EApSelCmdExit ); |
|
530 } |
|
531 } |
|
532 } |
|
533 else |
|
534 { |
|
535 if ( iExitReason == EShutDown ) |
|
536 { |
|
537 retval = ETrue; |
|
538 } |
|
539 else |
|
540 { |
|
541 if ( !(*iEventStore & KApUiEventShutDownRequested ) ) |
|
542 { |
|
543 retval = SaveDataL( ); |
|
544 } |
|
545 else |
|
546 { |
|
547 retval = ETrue; |
|
548 } |
|
549 } |
|
550 } |
|
551 } |
|
552 } |
|
553 } |
|
554 |
|
555 APSETUILOGGER_LEAVEFN( ESettings,"Settings::OkToExitL") |
|
556 return retval; |
|
557 } |
|
558 |
|
559 |
|
560 |
|
561 |
|
562 // --------------------------------------------------------- |
|
563 // CApSettingsDlg::InitTextsL |
|
564 // called before the dialog is shown |
|
565 // to initialize localized textual data |
|
566 // --------------------------------------------------------- |
|
567 // |
|
568 void CApSettingsDlg::InitTextsL() |
|
569 { |
|
570 APSETUILOGGER_ENTERFN( ESettings,"Settings::InitTextsL") |
|
571 |
|
572 // set pane texts |
|
573 // first get StatusPane |
|
574 iStatusPane = iEikonEnv->AppUiFactory()->StatusPane(); |
|
575 // then get TitlePane |
|
576 iTitlePane = ( CAknTitlePane* ) iStatusPane->ControlL( |
|
577 TUid::Uid( EEikStatusPaneUidTitle ) ); |
|
578 // if not already stored, store it for restoring |
|
579 if ( !iOldTitleText ) |
|
580 { |
|
581 iOldTitleText = iTitlePane->Text()->AllocL(); |
|
582 } |
|
583 // set new titlepane text |
|
584 iTitlePane->SetTextL( iApItem->ConnectionName() ); |
|
585 // if not already done, clear NaviPane with adding en empty one |
|
586 if ( !iNaviDecorator ) |
|
587 { |
|
588 iNaviPane = ( CAknNavigationControlContainer* ) |
|
589 iStatusPane->ControlL( |
|
590 TUid::Uid( EEikStatusPaneUidNavi ) ); |
|
591 iNaviDecorator = iNaviPane->CreateNavigationLabelL( KEmpty ); |
|
592 iNaviPane->PushL( *iNaviDecorator ); |
|
593 } |
|
594 |
|
595 APSETUILOGGER_LEAVEFN( ESettings,"Settings::InitTextsL") |
|
596 } |
|
597 |
|
598 |
|
599 |
|
600 |
|
601 // --------------------------------------------------------- |
|
602 // CApSettingsDlg::DynInitMenuPaneL |
|
603 // --------------------------------------------------------- |
|
604 // |
|
605 void CApSettingsDlg::DynInitMenuPaneL |
|
606 ( TInt aResourceId, CEikMenuPane* aMenuPane ) |
|
607 { |
|
608 APSETUILOGGER_ENTERFN( ESettings,"Settings::DynInitMenuPaneL") |
|
609 |
|
610 CAknDialog::DynInitMenuPaneL( aResourceId, aMenuPane ); |
|
611 if ( aResourceId == R_APSETTINGS_MENU ) |
|
612 { |
|
613 if ( iLevel ) |
|
614 { |
|
615 // Disallow Advanced settings item if already in advanced |
|
616 // or in SMS. |
|
617 aMenuPane->DeleteMenuItem( EApSelCmdAdvanced ); |
|
618 } |
|
619 if ( !iHelpSupported ) |
|
620 { |
|
621 aMenuPane->DeleteMenuItem( EAknCmdHelp ); |
|
622 } |
|
623 } |
|
624 |
|
625 APSETUILOGGER_LEAVEFN( ESettings,"Settings::DynInitMenuPaneL") |
|
626 } |
|
627 |
|
628 |
|
629 |
|
630 // --------------------------------------------------------- |
|
631 // CApSettingsDlg::HandleListboxDataChangeL |
|
632 // called before the dialog is shown to initialize listbox data |
|
633 // --------------------------------------------------------- |
|
634 // |
|
635 void CApSettingsDlg::HandleListboxDataChangeL( TBool aReRead ) |
|
636 { |
|
637 APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListboxDataChangeL") |
|
638 |
|
639 if ( aReRead && ( *iUid != KApNoneUID ) ) |
|
640 { // reload the whole ApItem ! |
|
641 // if it does not yet exists, no need to do so... |
|
642 iDataModel->AccessPointDataL( *iUid, *iApItem ); |
|
643 iDataModel->ClearWEPAndWPASettings(); |
|
644 } |
|
645 |
|
646 iBearerType = iApItem->BearerTypeL(); |
|
647 |
|
648 // fill up our new list with data |
|
649 CDesCArrayFlat* ItemArray = new ( ELeave ) CDesCArrayFlat( 4 ); |
|
650 CleanupStack::PushL( ItemArray ); |
|
651 switch ( iLevel ) |
|
652 { |
|
653 case 0: |
|
654 { |
|
655 FillListWithDataL( *ItemArray, *iField, iFieldCount, |
|
656 iTitles, iCompulsory ); |
|
657 break; |
|
658 } |
|
659 case 1: |
|
660 { |
|
661 FillListWithDataL( *ItemArray, *iFieldAdvanced, |
|
662 iAdvancedFieldCount, iTitlesAdvanced, |
|
663 iCompulsoryAdvanced ); |
|
664 break; |
|
665 } |
|
666 case 2: |
|
667 { |
|
668 FillListWithDataL( *ItemArray, *iFieldL2, iFieldCountL2, |
|
669 iTitlesL2, iCompulsoryL2 ); |
|
670 break; |
|
671 } |
|
672 default: |
|
673 { |
|
674 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
675 break; |
|
676 } |
|
677 } |
|
678 |
|
679 |
|
680 // if not already stored, store it for restoring |
|
681 if ( !iOldTitleText ) |
|
682 { |
|
683 iOldTitleText = iTitlePane->Text()->AllocL(); |
|
684 } |
|
685 // set new title text |
|
686 if ( iLevel == 2 ) |
|
687 { |
|
688 HBufC* value; |
|
689 if ( iL2Ipv4 ) |
|
690 { |
|
691 value = iEikonEnv->AllocReadResourceLC( |
|
692 R_APUI_VIEW_IPV4_SETTINGS ); |
|
693 } |
|
694 else |
|
695 { |
|
696 value = iEikonEnv->AllocReadResourceLC( |
|
697 R_APUI_VIEW_IPV6_SETTINGS ); |
|
698 } |
|
699 iTitlePane->SetTextL( *value ); |
|
700 CleanupStack::PopAndDestroy( value ); |
|
701 } |
|
702 else |
|
703 { |
|
704 iTitlePane->SetTextL( iApItem->ConnectionName() ); |
|
705 } |
|
706 |
|
707 iList->Model()->SetItemTextArray( ItemArray ); |
|
708 // now it is owned by the LB, so pop it |
|
709 CleanupStack::Pop(); // do not destroy ! |
|
710 iItemArray = ItemArray; |
|
711 |
|
712 iList->HandleItemAdditionL(); |
|
713 |
|
714 APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListboxDataChangeL") |
|
715 } |
|
716 |
|
717 |
|
718 |
|
719 // --------------------------------------------------------- |
|
720 // CApSettingsDlg::SetTextOverrides |
|
721 // --------------------------------------------------------- |
|
722 // |
|
723 void CApSettingsDlg::SetTextOverrides( CTextOverrides* aOverrides ) |
|
724 { |
|
725 APSETUILOGGER_ENTERFN( ESettings,"Settings::SetTextOverrides<->") |
|
726 |
|
727 __ASSERT_DEBUG( aOverrides, Panic( ENullPointer ) ); |
|
728 iTextOverrides = aOverrides; |
|
729 } |
|
730 |
|
731 |
|
732 |
|
733 // --------------------------------------------------------- |
|
734 // CApSettingsDlg::HandleApDbEventL |
|
735 // called by the active access point framework |
|
736 // --------------------------------------------------------- |
|
737 // |
|
738 void CApSettingsDlg::HandleApDbEventL( TEvent anEvent ) |
|
739 { |
|
740 APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleApDbEventL") |
|
741 |
|
742 switch ( anEvent ) |
|
743 { |
|
744 case EDbChanged: |
|
745 { |
|
746 HandleListboxDataChangeL( ETrue ); |
|
747 break; |
|
748 } |
|
749 case EDbClosing: |
|
750 { |
|
751 break; |
|
752 } |
|
753 case EDbAvailable: |
|
754 { |
|
755 break; |
|
756 } |
|
757 default: |
|
758 { |
|
759 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
760 break; |
|
761 } |
|
762 } |
|
763 |
|
764 APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleApDbEventL") |
|
765 } |
|
766 |
|
767 |
|
768 |
|
769 // --------------------------------------------------------- |
|
770 // CApSettingsDlg::GetHelpContext() |
|
771 // --------------------------------------------------------- |
|
772 // |
|
773 void CApSettingsDlg::GetHelpContext(TCoeHelpContext& aContext) const |
|
774 { |
|
775 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetHelpContext") |
|
776 |
|
777 aContext.iMajor = iHandler->iHelpMajor; |
|
778 switch ( iBearerType ) |
|
779 { |
|
780 case EApBearerTypeCSD: |
|
781 case EApBearerTypeHSCSD: |
|
782 { |
|
783 switch ( iLevel ) |
|
784 { |
|
785 case 2: |
|
786 { |
|
787 if ( iL2Ipv4 ) |
|
788 { |
|
789 aContext.iContext = KSET_HLP_AP_DATA_AS_IPV4; |
|
790 } |
|
791 else |
|
792 { |
|
793 aContext.iContext = KSET_HLP_AP_DATA_AS_IPV6; |
|
794 } |
|
795 break; |
|
796 } |
|
797 case 1: |
|
798 { |
|
799 aContext.iContext = KSET_HLP_AP_SETTING_DATA_AS; |
|
800 break; |
|
801 } |
|
802 case 0: |
|
803 default: |
|
804 { |
|
805 aContext.iContext = KSET_HLP_AP_SETTING_DATA; |
|
806 break; |
|
807 } |
|
808 } |
|
809 break; |
|
810 } |
|
811 case EApBearerTypeGPRS: |
|
812 { |
|
813 if ( iLevel ) |
|
814 { |
|
815 aContext.iContext = KSET_HLP_AP_SETTING_GPRS_AS; |
|
816 } |
|
817 else |
|
818 { |
|
819 aContext.iContext = KSET_HLP_AP_SETTING_GPRS; |
|
820 } |
|
821 break; |
|
822 } |
|
823 case EApBearerTypeWLAN: |
|
824 { |
|
825 switch ( iLevel ) |
|
826 { |
|
827 case 2: |
|
828 { |
|
829 if ( iL2Ipv4 ) |
|
830 { |
|
831 aContext.iContext = KSET_HLP_AP_WLAN_AS_IPV4; |
|
832 } |
|
833 else |
|
834 { |
|
835 aContext.iContext = KSET_HLP_AP_WLAN_AS_IPV6; |
|
836 } |
|
837 break; |
|
838 } |
|
839 case 1: |
|
840 { |
|
841 aContext.iContext = KSET_HLP_AP_SETTING_WLAN_AS; |
|
842 break; |
|
843 } |
|
844 case 0: |
|
845 { |
|
846 aContext.iContext = KSET_HLP_AP_SETTING_WLAN; |
|
847 break; |
|
848 } |
|
849 default: |
|
850 { |
|
851 break; |
|
852 } |
|
853 } |
|
854 break; |
|
855 } |
|
856 default: |
|
857 { |
|
858 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
859 break; |
|
860 } |
|
861 } |
|
862 |
|
863 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetHelpContext") |
|
864 } |
|
865 |
|
866 |
|
867 // --------------------------------------------------------- |
|
868 // CApSettingsDlg::PreLayoutDynInitL(); |
|
869 // called by framework before dialog is shown |
|
870 // --------------------------------------------------------- |
|
871 // |
|
872 void CApSettingsDlg::PreLayoutDynInitL() |
|
873 { |
|
874 APSETUILOGGER_ENTERFN( ESettings,"Settings::PreLayoutDynInitL") |
|
875 |
|
876 InitTextsL(); |
|
877 |
|
878 iList = STATIC_CAST( CAknSettingStyleListBox*, |
|
879 Control( KApSettingsListboxId ) ); |
|
880 |
|
881 iList->CreateScrollBarFrameL( ETrue ); |
|
882 iList->ScrollBarFrame()->SetScrollBarVisibilityL |
|
883 ( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto ); |
|
884 HandleListboxDataChangeL( EFalse ); |
|
885 iList->SetCurrentItemIndex( 0 ); |
|
886 iList->SetListBoxObserver( this ); |
|
887 |
|
888 iDataModel->Database()->AddObserverL( this ); |
|
889 |
|
890 APSETUILOGGER_LEAVEFN( ESettings,"Settings::PreLayoutDynInitL") |
|
891 } |
|
892 |
|
893 |
|
894 |
|
895 |
|
896 // From MEikCommandObserver |
|
897 void CApSettingsDlg::ProcessCommandL( TInt aCommandId ) |
|
898 { |
|
899 APSETUILOGGER_ENTERFN( ESettings,"Settings::ProcessCommandL") |
|
900 |
|
901 if ( MenuShowing() ) |
|
902 { |
|
903 HideMenu(); |
|
904 } |
|
905 |
|
906 switch ( aCommandId ) |
|
907 { |
|
908 case EApSelCmdQuickChange: |
|
909 { |
|
910 ChangeSettingsL( ETrue ); |
|
911 break; |
|
912 } |
|
913 case EApSelCmdChange: |
|
914 { |
|
915 ChangeSettingsL( EFalse ); |
|
916 break; |
|
917 } |
|
918 case EApSelCmdAdvanced: |
|
919 { |
|
920 if ( iLevel == 0 ) |
|
921 { |
|
922 iLevel ++; |
|
923 iOldIndex = iList->CurrentItemIndex(); |
|
924 iOldTopIndex = iList->TopItemIndex(); |
|
925 iList->SetCurrentItemIndex( 0 ); |
|
926 TRAPD( err, HandleListboxDataChangeL( EFalse ) ); |
|
927 if ( err ) |
|
928 { |
|
929 iLevel--; |
|
930 User::Leave( err ); |
|
931 } |
|
932 } |
|
933 break; |
|
934 } |
|
935 case EAknCmdHelp: |
|
936 { |
|
937 if ( iHelpSupported ) |
|
938 { |
|
939 iDataModel->LaunchHelpL(); |
|
940 } |
|
941 break; |
|
942 } |
|
943 // case EAknSoftkeyBack: |
|
944 case EApSelCmdExit: |
|
945 { |
|
946 iExitReason = EExit; |
|
947 *iEventStore |= KApUiEventExitRequested; |
|
948 TryExitL( EAknSoftkeyBack ); |
|
949 break; |
|
950 } |
|
951 case EAknCmdExit: |
|
952 case EEikCmdExit: |
|
953 { |
|
954 *iEventStore |= KApUiEventShutDownRequested; |
|
955 iExitReason = EShutDown; |
|
956 TryExitL( EAknSoftkeyBack ); |
|
957 break; |
|
958 } |
|
959 default: |
|
960 { |
|
961 // silently ignore it |
|
962 break; |
|
963 } |
|
964 } |
|
965 |
|
966 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ProcessCommandL") |
|
967 } |
|
968 |
|
969 |
|
970 // From MEikListBoxObserver |
|
971 void CApSettingsDlg::HandleListBoxEventL( CEikListBox* /*aListBox*/, |
|
972 TListBoxEvent aEventType ) |
|
973 { |
|
974 APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListBoxEventL") |
|
975 |
|
976 switch ( aEventType ) |
|
977 { |
|
978 case EEventEnterKeyPressed: |
|
979 // both handled in the same way for now... |
|
980 case EEventItemDoubleClicked: |
|
981 case EEventItemSingleClicked: |
|
982 { |
|
983 ChangeSettingsL( ETrue ); |
|
984 break; |
|
985 } |
|
986 case EEventItemClicked: |
|
987 { |
|
988 break; |
|
989 } |
|
990 case EEventEditingStarted: |
|
991 { |
|
992 break; |
|
993 } |
|
994 case EEventEditingStopped: |
|
995 { |
|
996 break; |
|
997 } |
|
998 default: |
|
999 { |
|
1000 // __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
1001 }; |
|
1002 }; |
|
1003 |
|
1004 APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListBoxEventL") |
|
1005 } |
|
1006 |
|
1007 |
|
1008 |
|
1009 |
|
1010 //---------------------------------------------------------- |
|
1011 // CApSettingsDlg::FillListWithDataL |
|
1012 //---------------------------------------------------------- |
|
1013 // |
|
1014 void CApSettingsDlg::FillListWithDataL( CDesCArrayFlat& aItemArray, |
|
1015 const TApMember& arr, TInt aLength, |
|
1016 const TInt* aRes, |
|
1017 const TInt* aCompulsory ) |
|
1018 { |
|
1019 APSETUILOGGER_ENTERFN( ESettings,"Settings::FillListWithDataL") |
|
1020 |
|
1021 TInt i; |
|
1022 TApMember* sgd = MUTABLE_CAST( TApMember*, &arr ); |
|
1023 for( i=0; i<aLength; i++ ) |
|
1024 { |
|
1025 switch ( *sgd ) |
|
1026 { |
|
1027 case EApWapGatewayAddress: |
|
1028 // case EApIspIPAddr: |
|
1029 case EApGprsIPNameServer1: |
|
1030 case EApIspIPNameServer1: |
|
1031 case EApGprsIPNameServer2: |
|
1032 case EApIspIPNameServer2: |
|
1033 case EApWapAccessPointName: |
|
1034 case EApWapStartPage: |
|
1035 case EApGprsAccessPointName: |
|
1036 case EApIspLoginName: |
|
1037 case EApIspLoginPass: |
|
1038 case EApIspIfAuthName: |
|
1039 case EApIspIfAuthPass: |
|
1040 case EApIspDefaultTelNumber: |
|
1041 case EApIspInitString: |
|
1042 case EApIspIfCallbackInfo: |
|
1043 case EApIspLoginScript: |
|
1044 case EApProxyServerAddress: |
|
1045 case EApProxyPortNumber: |
|
1046 case EApNetworkName: |
|
1047 case EApWlanNetworkName: |
|
1048 // case EApIspIPNetMask: |
|
1049 // case EApWlanIpGateway: |
|
1050 { |
|
1051 AddTextualListBoxItemL( aItemArray, *sgd, |
|
1052 *aRes, *aCompulsory ); |
|
1053 break; |
|
1054 } |
|
1055 case EApWlanIpNetMask: |
|
1056 case EApIspIPNetMask: |
|
1057 case EApIspIPGateway: |
|
1058 case EApWlanIpGateway: |
|
1059 { // check if they do really needed to be displayed... |
|
1060 if ( IsNetMaskAndGatewayVisibleL() ) |
|
1061 { |
|
1062 AddTextualListBoxItemL( aItemArray, *sgd, |
|
1063 *aRes, *aCompulsory ); |
|
1064 } |
|
1065 break; |
|
1066 } |
|
1067 case EApIspIPAddr: |
|
1068 { // GPRS, IPv4 or CSD, IPv4 settings |
|
1069 if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) |
|
1070 { |
|
1071 TUint32 tint; |
|
1072 iApItem->ReadUint( EApGprsPdpType, tint ); |
|
1073 if ( tint != EIPv6 ) |
|
1074 { |
|
1075 AddTextualListBoxItemL( aItemArray, *sgd, |
|
1076 *aRes, *aCompulsory ); |
|
1077 } |
|
1078 } |
|
1079 else |
|
1080 { // CSD |
|
1081 if ( iL2Ipv4 ) |
|
1082 { |
|
1083 AddTextualListBoxItemL( aItemArray, *sgd, |
|
1084 *aRes, *aCompulsory ); |
|
1085 } |
|
1086 } |
|
1087 break; |
|
1088 } |
|
1089 case EApWapCurrentBearer: |
|
1090 case EApWapSecurity: |
|
1091 case EApWapWspOption: |
|
1092 case EApIspPromptForLogin: |
|
1093 case EApGprsDisablePlainTextAuth: |
|
1094 case EApIspDisablePlainTextAuth: |
|
1095 case EApIspBearerCallTypeIsdn: |
|
1096 case EApIspIfCallbackEnabled: |
|
1097 case EApIspIfCallbackType: |
|
1098 case EApIspEnableSWCompression: |
|
1099 case EApGprsHeaderCompression: |
|
1100 case EApIspUseLoginScript: |
|
1101 case EApIspBearerSpeed: |
|
1102 case EApGprsPdpType: |
|
1103 case EApIP6DNSAddrFromServer: |
|
1104 case EApWlanNetworkMode: |
|
1105 case EApWlanSecurityMode: |
|
1106 case EApWlanScanSSID: |
|
1107 { |
|
1108 AddOnOffListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); |
|
1109 break; |
|
1110 } |
|
1111 case EApWlanChannelId: |
|
1112 { |
|
1113 if ( IsAdhocChannelVisible() ) |
|
1114 { |
|
1115 AddOnOffListBoxItemL( aItemArray, *sgd, *aRes, |
|
1116 *aCompulsory ); |
|
1117 } |
|
1118 break; |
|
1119 } |
|
1120 case EApIpv4Settings: |
|
1121 case EApIpv6Settings: |
|
1122 { |
|
1123 AddMenuListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); |
|
1124 break; |
|
1125 } |
|
1126 case EApWlanSecuritySettings: |
|
1127 { |
|
1128 AddMenuListBoxItemL( aItemArray, *sgd, *aRes, *aCompulsory ); |
|
1129 break; |
|
1130 } |
|
1131 default: |
|
1132 { |
|
1133 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
1134 break; |
|
1135 } |
|
1136 } |
|
1137 sgd++; |
|
1138 aRes++; |
|
1139 aCompulsory++; |
|
1140 } |
|
1141 |
|
1142 APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillListWithDataL") |
|
1143 } |
|
1144 |
|
1145 |
|
1146 //---------------------------------------------------------- |
|
1147 // CApSettingsDlg::AddTextualListBoxItemL |
|
1148 //---------------------------------------------------------- |
|
1149 // |
|
1150 void CApSettingsDlg::AddTextualListBoxItemL( CDesCArrayFlat& aItemArray, |
|
1151 TApMember aMember, TInt aRes, |
|
1152 TInt aCompulsory ) |
|
1153 { |
|
1154 APSETUILOGGER_ENTERFN( ESettings,"Settings::AddTextualListBoxItemL") |
|
1155 |
|
1156 HBufC* sgd = CreateTextualListBoxItemL( aMember, aRes, aCompulsory ); |
|
1157 CleanupStack::PushL( sgd ); |
|
1158 aItemArray.AppendL( sgd->Des() ); |
|
1159 CleanupStack::PopAndDestroy( sgd ); |
|
1160 |
|
1161 APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddTextualListBoxItemL") |
|
1162 } |
|
1163 |
|
1164 |
|
1165 //---------------------------------------------------------- |
|
1166 // CApSettingsDlg::AddOnOffListBoxItem |
|
1167 //---------------------------------------------------------- |
|
1168 // |
|
1169 void CApSettingsDlg::AddOnOffListBoxItemL( CDesCArrayFlat& aItemArray, |
|
1170 TApMember aMember, TInt aRes, |
|
1171 TInt aCompulsory ) |
|
1172 { |
|
1173 APSETUILOGGER_ENTERFN( ESettings,"Settings::AddOnOffListBoxItemL") |
|
1174 |
|
1175 // Read up title text from resource |
|
1176 HBufC* sgd = CreateOnOffListBoxItemL( aMember, aRes, aCompulsory ); |
|
1177 CleanupStack::PushL( sgd ); |
|
1178 aItemArray.AppendL( sgd->Des() ); |
|
1179 CleanupStack::PopAndDestroy( sgd ); |
|
1180 |
|
1181 APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddOnOffListBoxItemL") |
|
1182 } |
|
1183 |
|
1184 |
|
1185 //---------------------------------------------------------- |
|
1186 // CApSettingsDlg::UpdateOnOffListBoxItemL |
|
1187 //---------------------------------------------------------- |
|
1188 // |
|
1189 void CApSettingsDlg::UpdateOnOffListBoxItemL( TApMember aMember, TInt aRes, |
|
1190 TInt aPos, TInt aCompulsory ) |
|
1191 { |
|
1192 APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateOnOffListBoxItemL") |
|
1193 |
|
1194 // Read up title text from resource |
|
1195 HBufC* sgd = CreateOnOffListBoxItemL( aMember, aRes, aCompulsory ); |
|
1196 CleanupStack::PushL( sgd ); |
|
1197 // first try to add, if Leaves, list will be untouched |
|
1198 iItemArray->InsertL( aPos, sgd->Des() ); |
|
1199 // if successful, previous item is scrolled up with one, |
|
1200 // so delete that one... |
|
1201 if ( ++aPos < iItemArray->MdcaCount() ) |
|
1202 { |
|
1203 iItemArray->Delete( aPos ); |
|
1204 } |
|
1205 CleanupStack::PopAndDestroy( sgd ); |
|
1206 |
|
1207 APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateOnOffListBoxItemL") |
|
1208 } |
|
1209 |
|
1210 |
|
1211 //---------------------------------------------------------- |
|
1212 // CApSettingsDlg::TextualListBoxItemL |
|
1213 //---------------------------------------------------------- |
|
1214 // |
|
1215 void CApSettingsDlg::UpdateTextualListBoxItemL( TApMember aMember, TInt aRes, |
|
1216 TInt aPos, TInt aCompulsory ) |
|
1217 { |
|
1218 APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateTextualListBoxItemL") |
|
1219 |
|
1220 HBufC* sgd = CreateTextualListBoxItemL( aMember, aRes, aCompulsory ); |
|
1221 CleanupStack::PushL( sgd ); |
|
1222 // first try to add, if Leaves, list will be untouched |
|
1223 iItemArray->InsertL( aPos, sgd->Des() ); |
|
1224 // if successful, previous item is scrolled up with one, |
|
1225 // so delete that one... |
|
1226 if ( ++aPos < iItemArray->MdcaCount() ) |
|
1227 { |
|
1228 iItemArray->Delete( aPos ); |
|
1229 } |
|
1230 CleanupStack::PopAndDestroy( sgd ); |
|
1231 |
|
1232 APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateTextualListBoxItemL") |
|
1233 } |
|
1234 |
|
1235 |
|
1236 //---------------------------------------------------------- |
|
1237 // CApSettingsDlg::CreateTextualListBoxItem |
|
1238 //---------------------------------------------------------- |
|
1239 // |
|
1240 HBufC* CApSettingsDlg::CreateTextualListBoxItemL( TApMember aMember, |
|
1241 TInt aRes, |
|
1242 TInt aCompulsory ) |
|
1243 { |
|
1244 APSETUILOGGER_ENTERFN( ESettings,"Settings::CreateTextualListBoxItemL") |
|
1245 |
|
1246 // both variables needed independently of the following |
|
1247 // conditions so I must declare them here... |
|
1248 HBufC16* value; |
|
1249 TBool Pushed( EFalse ); |
|
1250 if ( ( aMember == EApIspLoginScript ) || ( aMember == EApWapStartPage ) |
|
1251 || ( aMember == EApGprsAccessPointName ) |
|
1252 || ( aMember == EApProxyServerAddress ) ) |
|
1253 { |
|
1254 // allocates as much as needed... |
|
1255 value = iApItem->ReadConstLongTextL( aMember )->AllocLC(); |
|
1256 } |
|
1257 else |
|
1258 { |
|
1259 value = HBufC::NewLC( KModifiableTextLength ); |
|
1260 // handle different 'types' (8 bit or 16 bit) descriptors |
|
1261 // and bring them to common base (16 bit...) |
|
1262 if ( ( aMember == EApIspIfCallbackInfo ) |
|
1263 || ( aMember == EApIspInitString ) ) |
|
1264 { |
|
1265 HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); |
|
1266 TPtr8 ptr( tmpValue8->Des() ); |
|
1267 iApItem->ReadTextL( aMember, ptr ); |
|
1268 value->Des().Copy( *tmpValue8 ); |
|
1269 CleanupStack::PopAndDestroy(); // tmpValue8 |
|
1270 } |
|
1271 else |
|
1272 { |
|
1273 if ( aMember == EApProxyPortNumber ) |
|
1274 { |
|
1275 TUint32 tempint; |
|
1276 iApItem->ReadUint( aMember, tempint ); |
|
1277 TPtr ptr( value->Des() ); |
|
1278 ptr.Format( KTxtNumber, tempint ); |
|
1279 } |
|
1280 else |
|
1281 { |
|
1282 TPtr16 ptr( value->Des() ); |
|
1283 if ( ( aMember == EApIspIfAuthPass ) |
|
1284 || ( aMember == EApIspLoginPass ) ) |
|
1285 { |
|
1286 ptr.SetLength( KStaredPasswordLength ); |
|
1287 ptr.Fill( '*' ); |
|
1288 } |
|
1289 else |
|
1290 { |
|
1291 iApItem->ReadTextL( aMember, ptr ); |
|
1292 } |
|
1293 } |
|
1294 } |
|
1295 switch ( aMember ) |
|
1296 { |
|
1297 case EApIspIPAddr: |
|
1298 { |
|
1299 if ( ( value->Compare( KDynIpAddress ) == 0 ) |
|
1300 || ( value->Compare( KEmptyText ) == 0 ) ) |
|
1301 { |
|
1302 value = iEikonEnv->AllocReadResourceLC( |
|
1303 R_APUI_VIEW_IP_ADDR_DYNAMIC ); |
|
1304 Pushed = ETrue; |
|
1305 } |
|
1306 break; |
|
1307 } |
|
1308 case EApIspIPNetMask: |
|
1309 case EApIspIPGateway: |
|
1310 case EApWlanIpNetMask: |
|
1311 case EApWlanIpGateway: |
|
1312 { |
|
1313 if ( ( value->Compare( KDynIpAddress ) == 0 ) |
|
1314 || ( value->Compare( KEmptyText ) == 0 ) ) |
|
1315 { |
|
1316 value = iEikonEnv->AllocReadResourceLC( |
|
1317 R_APUI_VIEW_COMPULSORY ); |
|
1318 Pushed = ETrue; |
|
1319 } |
|
1320 break; |
|
1321 } |
|
1322 case EApGprsIPNameServer1: |
|
1323 case EApIspIPNameServer1: |
|
1324 case EApGprsIPNameServer2: |
|
1325 case EApIspIPNameServer2: |
|
1326 { |
|
1327 if ( ( value->Compare( KDynIpAddress ) == 0 ) |
|
1328 || ( value->Compare( KEmptyText ) == 0 ) ) |
|
1329 { |
|
1330 value = iEikonEnv->AllocReadResourceLC( |
|
1331 R_APUI_VIEW_NEW_AP_DNS_SERVER_AUTOMATIC ); |
|
1332 Pushed = ETrue; |
|
1333 } |
|
1334 break; |
|
1335 } |
|
1336 case EApIspDefaultTelNumber: |
|
1337 case EApWlanNetworkName: |
|
1338 { |
|
1339 if ( value->Compare( KEmptyText ) == 0 ) |
|
1340 { |
|
1341 value = iEikonEnv->AllocReadResourceLC( |
|
1342 R_APUI_VIEW_AVKON_COMPULSORY ); |
|
1343 Pushed = ETrue; |
|
1344 } |
|
1345 break; |
|
1346 } |
|
1347 default: |
|
1348 { |
|
1349 break; |
|
1350 } |
|
1351 } |
|
1352 } |
|
1353 // Define a heap descriptor to hold all the item text |
|
1354 // HBufC is non-modifiable |
|
1355 HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); |
|
1356 |
|
1357 HBufC* value1 = ReplaceWhiteSpaceCharactersLC( *value ); |
|
1358 |
|
1359 if ( value1->CompareC( KEmpty ) == 0 ) |
|
1360 { // empty, get 'None' as value |
|
1361 HBufC* temp = NULL; |
|
1362 switch ( aMember ) |
|
1363 { |
|
1364 case EApWapStartPage: |
|
1365 { // get special None for homepage |
|
1366 temp = iEikonEnv->AllocReadResourceLC( |
|
1367 R_APUI_SETT_HOME_PAGE_NONE ); |
|
1368 break; |
|
1369 } |
|
1370 case EApIspIfAuthName: |
|
1371 { // user name none |
|
1372 temp = iEikonEnv->AllocReadResourceLC( |
|
1373 R_APUI_VIEW_NEW_AP_USER_NAME_NONE ); |
|
1374 break; |
|
1375 } |
|
1376 case EApProxyServerAddress: |
|
1377 { // proxy server address none |
|
1378 temp = iEikonEnv->AllocReadResourceLC( |
|
1379 R_APUI_VIEW_NEW_AP_PROXY_SERVER_ADDR_NONE ); |
|
1380 break; |
|
1381 } |
|
1382 case EApIspIfCallbackInfo: |
|
1383 { // callback number none |
|
1384 temp = iEikonEnv->AllocReadResourceLC( |
|
1385 R_APUI_VIEW_NEW_AP_CB_NUMBER_NONE ); |
|
1386 break; |
|
1387 } |
|
1388 case EApIspLoginScript: |
|
1389 { // login script none |
|
1390 temp = iEikonEnv->AllocReadResourceLC( |
|
1391 R_APUI_VIEW_NEW_AP_LOGIN_SCRIPT_NONE ); |
|
1392 break; |
|
1393 } |
|
1394 case EApIspInitString: |
|
1395 { // modem init string none |
|
1396 temp = iEikonEnv->AllocReadResourceLC( |
|
1397 R_APUI_VIEW_NEW_AP_MODEM_INIT_NONE ); |
|
1398 break; |
|
1399 } |
|
1400 default: |
|
1401 { // get 'normal' None for others |
|
1402 temp = |
|
1403 iEikonEnv->AllocReadResourceLC( |
|
1404 R_APUI_SETT_VAL_FIELD_NONE ); |
|
1405 break; |
|
1406 } |
|
1407 } |
|
1408 CleanupStack::Pop(); // temp |
|
1409 CleanupStack::PopAndDestroy( value1 ); |
|
1410 CleanupStack::PushL( temp ); |
|
1411 value1 = temp; |
|
1412 } |
|
1413 |
|
1414 // Define a heap descriptor to hold all the item text |
|
1415 TInt length = title->Length() + value1->Length() + 10; |
|
1416 if ( aCompulsory ) |
|
1417 { |
|
1418 length += 3; |
|
1419 } |
|
1420 HBufC* itemText = HBufC::NewLC( length ); |
|
1421 |
|
1422 // handle exotic language number conversion here |
|
1423 TPtr t(title->Des()); |
|
1424 TPtr v(value1->Des()); |
|
1425 AknTextUtils::LanguageSpecificNumberConversion( t ); |
|
1426 AknTextUtils::LanguageSpecificNumberConversion( v ); |
|
1427 |
|
1428 // Define a modifiable pointer descriptor to be able to append text to the |
|
1429 // non-modifiable heap descriptor itemText |
|
1430 TPtr itemTextPtr = itemText->Des(); |
|
1431 itemTextPtr.Format( KTxtListItemFormat, title, value1 ); |
|
1432 if ( aCompulsory ) |
|
1433 { |
|
1434 itemTextPtr.Append( KTxtCompulsory ); |
|
1435 } |
|
1436 CleanupStack::Pop(); // itemtext, |
|
1437 if ( Pushed ) |
|
1438 { |
|
1439 // "Dynamic" text from resource if needed |
|
1440 CleanupStack::PopAndDestroy(); |
|
1441 } |
|
1442 // title, value, value1. !value is allocated with LC in both cases...! |
|
1443 CleanupStack::PopAndDestroy( 3 ); |
|
1444 |
|
1445 APSETUILOGGER_LEAVEFN( ESettings,"Settings::CreateTextualListBoxItemL") |
|
1446 return itemText; |
|
1447 } |
|
1448 |
|
1449 |
|
1450 |
|
1451 //---------------------------------------------------------- |
|
1452 // CApSettingsDlg::CreateOnOffListBoxItemL |
|
1453 //---------------------------------------------------------- |
|
1454 // |
|
1455 HBufC* CApSettingsDlg::CreateOnOffListBoxItemL( TApMember aMember, TInt aRes, |
|
1456 TInt aCompulsory ) |
|
1457 { |
|
1458 APSETUILOGGER_ENTERFN( ESettings,"Settings::CreateOnOffListBoxItemL") |
|
1459 |
|
1460 // Read up title text from resource |
|
1461 HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); |
|
1462 |
|
1463 TUint32 aValueResourceID = 0; |
|
1464 TBool bvar; |
|
1465 |
|
1466 switch ( aMember ) |
|
1467 { |
|
1468 case EApIspBearerCallTypeIsdn: |
|
1469 {// Data call type "Analogue"/"ISDN" |
|
1470 TUint32 tempint; |
|
1471 iApItem->ReadUint( EApIspBearerCallTypeIsdn, tempint ); |
|
1472 switch ( tempint ) |
|
1473 { |
|
1474 case ECallTypeISDNv110: |
|
1475 { |
|
1476 aValueResourceID = R_APUI_VIEW_DATACALL_ISDN_110; |
|
1477 break; |
|
1478 } |
|
1479 case ECallTypeISDNv120: |
|
1480 { |
|
1481 aValueResourceID = R_APUI_VIEW_DATACALL_ISDN_120; |
|
1482 break; |
|
1483 } |
|
1484 case ECallTypeAnalogue: |
|
1485 default: |
|
1486 { |
|
1487 aValueResourceID = R_APUI_VIEW_DATACALL_ANALOLGUE; |
|
1488 break; |
|
1489 } |
|
1490 } |
|
1491 break; |
|
1492 } |
|
1493 case EApWapWspOption: |
|
1494 { // "Continuous"/"Temporary" |
|
1495 TUint32 tval; |
|
1496 iApItem->ReadUint( aMember, tval ); |
|
1497 if ( tval == EWapWspOptionConnectionOriented ) |
|
1498 { |
|
1499 aValueResourceID = R_APUI_VIEW_CONN_TYPE_CONTIN; |
|
1500 } |
|
1501 else |
|
1502 { |
|
1503 aValueResourceID = R_APUI_VIEW_CONN_TYPE_TEMP; |
|
1504 } |
|
1505 break; |
|
1506 } |
|
1507 case EApIspIfCallbackType: |
|
1508 { // "Use server number"/"Use other number" |
|
1509 TUint32 tval; |
|
1510 iApItem->ReadUint( aMember, tval ); |
|
1511 if ( tval == ECallbackActionMSCBCPAcceptServerSpecifiedNumber ) |
|
1512 { |
|
1513 aValueResourceID = R_APUI_VIEW_CB_USE_SERVER_NUMBER; |
|
1514 } |
|
1515 else |
|
1516 { |
|
1517 if ( tval == |
|
1518 ECallbackActionMSCBCPRequireClientSpecifiedNumber ) |
|
1519 { |
|
1520 aValueResourceID = R_APUI_VIEW_CB_USE_OTHER_NUMBER; |
|
1521 } |
|
1522 } |
|
1523 break; |
|
1524 } |
|
1525 case EApWapSecurity: |
|
1526 { // on/off |
|
1527 iApItem->ReadBool( aMember, bvar ); |
|
1528 if ( bvar ) |
|
1529 { |
|
1530 aValueResourceID = R_APUI_VIEW_WTLS_SECURITY_ON; |
|
1531 } |
|
1532 else |
|
1533 { |
|
1534 aValueResourceID = R_APUI_VIEW_WTLS_SECURITY_OFF; |
|
1535 } |
|
1536 break; |
|
1537 } |
|
1538 case EApIspUseLoginScript: |
|
1539 { |
|
1540 iApItem->ReadBool( aMember, bvar ); |
|
1541 if ( bvar ) |
|
1542 { |
|
1543 aValueResourceID = R_APUI_VIEW_USE_LOGINS_YES; |
|
1544 } |
|
1545 else |
|
1546 { |
|
1547 aValueResourceID = R_APUI_VIEW_USE_LOGINS_NO; |
|
1548 } |
|
1549 break; |
|
1550 } |
|
1551 |
|
1552 case EApIspEnableSWCompression: |
|
1553 case EApGprsHeaderCompression: |
|
1554 { |
|
1555 iApItem->ReadBool( aMember, bvar ); |
|
1556 if ( bvar ) |
|
1557 { |
|
1558 aValueResourceID = R_APUI_VIEW_PPP_COMP_YES; |
|
1559 } |
|
1560 else |
|
1561 { |
|
1562 aValueResourceID = R_APUI_VIEW_PPP_COMP_NO; |
|
1563 } |
|
1564 break; |
|
1565 } |
|
1566 case EApIspPromptForLogin: |
|
1567 { |
|
1568 iApItem->ReadBool( aMember, bvar ); |
|
1569 if ( bvar ) |
|
1570 { |
|
1571 aValueResourceID = R_APUI_VIEW_PROMPT_PASSWD_YES; |
|
1572 } |
|
1573 else |
|
1574 { |
|
1575 aValueResourceID = R_APUI_VIEW_PROMPT_PASSWD_NO; |
|
1576 } |
|
1577 break; |
|
1578 } |
|
1579 case EApIspIfCallbackEnabled: |
|
1580 { // yes/no |
|
1581 iApItem->ReadBool( aMember, bvar ); |
|
1582 if ( bvar ) |
|
1583 { |
|
1584 aValueResourceID = R_APUI_VIEW_USE_CB_YES; |
|
1585 } |
|
1586 else |
|
1587 { |
|
1588 aValueResourceID = R_APUI_VIEW_USE_CB_NO; |
|
1589 } |
|
1590 break; |
|
1591 } |
|
1592 case EApWapCurrentBearer: |
|
1593 { // "Packet data"/"SMS"/"Data call" |
|
1594 if ( iBearerType == EApBearerTypeCSD ) |
|
1595 { |
|
1596 aValueResourceID = R_APUI_VIEW_BEARER_TYPE_CSD; |
|
1597 } |
|
1598 else |
|
1599 { |
|
1600 if ( iBearerType == EApBearerTypeHSCSD ) |
|
1601 { |
|
1602 aValueResourceID = R_APUI_VIEW_BEARER_TYPE_HSCSD; |
|
1603 } |
|
1604 else |
|
1605 { |
|
1606 if ( iBearerType == EApBearerTypeGPRS ) |
|
1607 { |
|
1608 aValueResourceID = R_APUI_VIEW_BEARER_TYPE_GPRS; |
|
1609 } |
|
1610 else |
|
1611 { |
|
1612 if ( IsWlanSupported() ) |
|
1613 { |
|
1614 if ( iBearerType == EApBearerTypeWLAN ) |
|
1615 { |
|
1616 aValueResourceID = |
|
1617 R_APUI_VIEW_BEARER_TYPE_WLAN; |
|
1618 } |
|
1619 else |
|
1620 { |
|
1621 User::Leave( KErrInvalidBearerType ); |
|
1622 } |
|
1623 } |
|
1624 else |
|
1625 { |
|
1626 User::Leave( KErrInvalidBearerType ); |
|
1627 } |
|
1628 } |
|
1629 } |
|
1630 } |
|
1631 break; |
|
1632 } |
|
1633 case EApGprsDisablePlainTextAuth: |
|
1634 case EApIspDisablePlainTextAuth: |
|
1635 { // "Normal"/"Secure" |
|
1636 iApItem->ReadBool( aMember, bvar ); |
|
1637 if ( bvar ) |
|
1638 { |
|
1639 aValueResourceID = R_APUI_VIEW_PASSWORD_AUTH_SECURE; |
|
1640 } |
|
1641 else |
|
1642 { |
|
1643 aValueResourceID = R_APUI_VIEW_PASSWORD_AUTH_NORMAL; |
|
1644 } |
|
1645 break; |
|
1646 } |
|
1647 case EApIspBearerSpeed: |
|
1648 { |
|
1649 TUint32 uvar; |
|
1650 iApItem->ReadUint( aMember, uvar ); |
|
1651 switch ( TApCallSpeed( uvar ) ) |
|
1652 { |
|
1653 case KSpeedAutobaud: |
|
1654 { |
|
1655 aValueResourceID = R_APUI_VIEW_SPEED_AUTODETECT; |
|
1656 break; |
|
1657 } |
|
1658 case KSpeed9600: |
|
1659 { |
|
1660 aValueResourceID = R_APUI_VIEW_SPEED_9600; |
|
1661 break; |
|
1662 } |
|
1663 case KSpeed14400: |
|
1664 { |
|
1665 aValueResourceID = R_APUI_VIEW_SPEED_14400; |
|
1666 break; |
|
1667 } |
|
1668 case KSpeed19200: |
|
1669 { |
|
1670 aValueResourceID = R_APUI_VIEW_SPEED_19200; |
|
1671 break; |
|
1672 } |
|
1673 case KSpeed28800: |
|
1674 { |
|
1675 aValueResourceID = R_APUI_VIEW_SPEED_28800; |
|
1676 break; |
|
1677 } |
|
1678 case KSpeed38400: |
|
1679 { |
|
1680 aValueResourceID = R_APUI_VIEW_SPEED_38400; |
|
1681 break; |
|
1682 } |
|
1683 case KSpeed43200: |
|
1684 { |
|
1685 aValueResourceID = R_APUI_VIEW_SPEED_43200; |
|
1686 break; |
|
1687 } |
|
1688 case KSpeed56000: |
|
1689 { |
|
1690 aValueResourceID = R_APUI_VIEW_SPEED_56000; |
|
1691 break; |
|
1692 } |
|
1693 default: |
|
1694 { |
|
1695 // auto-repair corrupted value |
|
1696 // use 9600 if previous data was not valid... |
|
1697 aValueResourceID = R_APUI_VIEW_SPEED_9600; |
|
1698 } |
|
1699 } |
|
1700 |
|
1701 break; |
|
1702 } |
|
1703 case EApGprsPdpType: |
|
1704 { |
|
1705 TUint32 uvar( 0 ); |
|
1706 iApItem->ReadUint( aMember, uvar ); |
|
1707 if ( uvar == EIPv6 ) |
|
1708 { |
|
1709 aValueResourceID = R_APUI_VIEW_PDP_TYPE_IPV6; |
|
1710 } |
|
1711 else |
|
1712 { |
|
1713 aValueResourceID = R_APUI_VIEW_PDP_TYPE_IPV4; |
|
1714 } |
|
1715 break; |
|
1716 } |
|
1717 case EApIP6DNSAddrFromServer: |
|
1718 { |
|
1719 // Change the 'magic numbers' |
|
1720 // Add the three possibilities here |
|
1721 iApItem->ReadBool( aMember, bvar ); |
|
1722 TInt stype = GetDomainNameServersTypeL(); |
|
1723 |
|
1724 switch ( stype ) |
|
1725 { |
|
1726 case 0: |
|
1727 { |
|
1728 aValueResourceID = |
|
1729 R_APUI_VIEW_NEW_AP_DNS_SERVERS_AUTOMATIC; |
|
1730 break; |
|
1731 } |
|
1732 case 1: |
|
1733 { |
|
1734 aValueResourceID = R_APUI_VIEW_SET_IP_WELL_KNOWN; |
|
1735 break; |
|
1736 } |
|
1737 case 2: |
|
1738 { |
|
1739 aValueResourceID = R_APUI_VIEW_SET_IP_USER_DEFINED; |
|
1740 break; |
|
1741 } |
|
1742 default: |
|
1743 { |
|
1744 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
1745 break; |
|
1746 } |
|
1747 } |
|
1748 break; |
|
1749 } |
|
1750 case EApWlanNetworkMode: |
|
1751 { |
|
1752 TUint32 netmode( 0 ); |
|
1753 iApItem->ReadUint( aMember, netmode ); |
|
1754 if ( netmode == EAdhoc ) |
|
1755 { |
|
1756 aValueResourceID = R_APUI_VIEW_WLAN_NETWORK_MODE_ADHOC; |
|
1757 } |
|
1758 else |
|
1759 { |
|
1760 aValueResourceID = R_APUI_VIEW_WLAN_NETWORK_MODE_INFRA; |
|
1761 } |
|
1762 break; |
|
1763 } |
|
1764 case EApWlanSecurityMode: |
|
1765 { |
|
1766 TUint32 secmode( 0 ); |
|
1767 iApItem->ReadUint( aMember, secmode ); |
|
1768 switch ( secmode ) |
|
1769 { |
|
1770 case EOpen: |
|
1771 { |
|
1772 aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN; |
|
1773 break; |
|
1774 } |
|
1775 case EWep: |
|
1776 { |
|
1777 aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_WEP; |
|
1778 break; |
|
1779 } |
|
1780 case E802_1x: |
|
1781 { |
|
1782 aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_802_1X; |
|
1783 break; |
|
1784 } |
|
1785 case EWpa: |
|
1786 case EWpa2: |
|
1787 { |
|
1788 aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_WPA; |
|
1789 break; |
|
1790 } |
|
1791 default: |
|
1792 { |
|
1793 aValueResourceID = R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN; |
|
1794 break; |
|
1795 } |
|
1796 } |
|
1797 |
|
1798 break; |
|
1799 } |
|
1800 case EApWlanScanSSID: |
|
1801 { // yes/no |
|
1802 iApItem->ReadBool( aMember, bvar ); |
|
1803 if ( bvar ) |
|
1804 { |
|
1805 aValueResourceID = R_APUI_VIEW_HIDDEN_NETWORK_YES; |
|
1806 } |
|
1807 else |
|
1808 { |
|
1809 aValueResourceID = R_APUI_VIEW_HIDDEN_NETWORK_NO; |
|
1810 } |
|
1811 break; |
|
1812 } |
|
1813 case EApWlanChannelId: |
|
1814 { // ad-hoc channel auto / user defined |
|
1815 TUint32 channel(0); |
|
1816 iApItem->ReadUint( aMember, channel ); |
|
1817 if ( channel ) |
|
1818 { |
|
1819 aValueResourceID = R_APUI_VIEW_AD_HOC_CHANNEL_USER_DEFINED; |
|
1820 } |
|
1821 else |
|
1822 { |
|
1823 aValueResourceID = R_APUI_VIEW_AD_HOC_CHANNEL_AUTO; |
|
1824 } |
|
1825 break; |
|
1826 } |
|
1827 default: |
|
1828 { |
|
1829 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
1830 break; |
|
1831 } |
|
1832 } |
|
1833 |
|
1834 HBufC* value; |
|
1835 if ( aValueResourceID ) |
|
1836 { |
|
1837 // Read up value text from resource |
|
1838 value = iEikonEnv->AllocReadResourceLC( aValueResourceID ); |
|
1839 } |
|
1840 else |
|
1841 { |
|
1842 value = HBufC::NewLC( 0 ); |
|
1843 } |
|
1844 |
|
1845 |
|
1846 // Define a heap descriptor to hold all the item text |
|
1847 TInt length = title->Length() + value->Length() + 10 ; |
|
1848 if ( aCompulsory ) |
|
1849 { |
|
1850 length += 3; |
|
1851 } |
|
1852 |
|
1853 HBufC* itemText = HBufC::NewLC( length); |
|
1854 |
|
1855 // Define a modifiable pointer descriptor to be able to append text to the |
|
1856 // non-modifiable heap descriptor itemText |
|
1857 TPtr itemTextPtr = itemText->Des(); |
|
1858 itemTextPtr.Format( KTxtListItemFormat, title, value); |
|
1859 if ( aCompulsory ) |
|
1860 { |
|
1861 itemTextPtr.Append( KTxtCompulsory ); |
|
1862 } |
|
1863 |
|
1864 CleanupStack::Pop(); // itemText |
|
1865 CleanupStack::PopAndDestroy( 2 ); // value, title |
|
1866 |
|
1867 APSETUILOGGER_LEAVEFN( ESettings,"Settings::CreateOnOffListBoxItemL") |
|
1868 return itemText; |
|
1869 } |
|
1870 |
|
1871 |
|
1872 |
|
1873 //---------------------------------------------------------- |
|
1874 // CApSettingsDlg::ChangeSettingsL |
|
1875 //---------------------------------------------------------- |
|
1876 // |
|
1877 void CApSettingsDlg::ChangeSettingsL( TBool aQuick ) |
|
1878 { |
|
1879 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeSettingsL") |
|
1880 |
|
1881 #ifdef __TEST_OOMDEBUG |
|
1882 if ( iMemTestOn ) |
|
1883 { |
|
1884 TInt leavecode( KErrNoMemory ); |
|
1885 |
|
1886 TInt ts( GetTestStateL() ); |
|
1887 |
|
1888 if ( ts == KEditingTest ) |
|
1889 { |
|
1890 TBuf<48> buf; |
|
1891 APSETUILOGGER_WRITE_BUF( _L("Starting Editing memtest") ); |
|
1892 |
|
1893 TUint32 rate( 0 ); |
|
1894 TUint32 retrycount( KOOMRetryCount ); |
|
1895 TUint32 retryoffset( KOOMRetryOffset ); |
|
1896 for ( |
|
1897 rate = 1; |
|
1898 ((rate < 50000) && (leavecode == KErrNoMemory)) || retrycount; |
|
1899 rate++ |
|
1900 ) |
|
1901 { |
|
1902 __UHEAP_SETFAIL( RHeap::EDeterministic, rate ); |
|
1903 TRAP( leavecode, DoChangeSettingsL( aQuick ) ); |
|
1904 __UHEAP_RESET; |
|
1905 if ( !leavecode ) |
|
1906 { |
|
1907 retrycount--; |
|
1908 rate += retryoffset; |
|
1909 } |
|
1910 } |
|
1911 User::LeaveIfError( leavecode ); |
|
1912 buf.Format( _L("\t Memtest finished, max. rate was: %d )"), rate ); |
|
1913 APSETUILOGGER_WRITE_BUF( buf ); |
|
1914 } |
|
1915 else |
|
1916 { |
|
1917 DoChangeSettingsL( aQuick ); |
|
1918 } |
|
1919 } |
|
1920 else |
|
1921 { |
|
1922 DoChangeSettingsL( aQuick ); |
|
1923 } |
|
1924 #else |
|
1925 DoChangeSettingsL( aQuick ); |
|
1926 #endif // __TEST_OOMDEBUG |
|
1927 |
|
1928 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeSettingsL") |
|
1929 } |
|
1930 |
|
1931 |
|
1932 |
|
1933 //---------------------------------------------------------- |
|
1934 // CApSettingsDlg::SetBearerTypeL |
|
1935 //---------------------------------------------------------- |
|
1936 // |
|
1937 void CApSettingsDlg::SetBearerTypeL( TApBearerType aBearer ) |
|
1938 { |
|
1939 APSETUILOGGER_ENTERFN( ESettings,"Settings::SetBearerTypeL") |
|
1940 |
|
1941 iBearerType = aBearer; |
|
1942 |
|
1943 HandleListStructureChangeL(); |
|
1944 |
|
1945 APSETUILOGGER_LEAVEFN( ESettings,"Settings::SetBearerTypeL") |
|
1946 } |
|
1947 |
|
1948 |
|
1949 |
|
1950 //---------------------------------------------------------- |
|
1951 // CApSettingsDlg::InvertSettingsL |
|
1952 //---------------------------------------------------------- |
|
1953 // |
|
1954 void CApSettingsDlg::InvertSettingsL( TApMember aDataMember ) |
|
1955 { |
|
1956 APSETUILOGGER_ENTERFN( ESettings,"Settings::InvertSettingsL") |
|
1957 |
|
1958 switch ( aDataMember ) |
|
1959 { |
|
1960 case EApIspIfCallbackType: |
|
1961 { |
|
1962 TUint32 ctype( ECallbackActionMSCBCPRequireClientSpecifiedNumber ); |
|
1963 iApItem->ReadUint( EApIspIfCallbackType, ctype ); |
|
1964 if ( ctype == ECallbackActionMSCBCPRequireClientSpecifiedNumber ) |
|
1965 { |
|
1966 iApItem->WriteUint( EApIspIfCallbackType, |
|
1967 ECallbackActionMSCBCPAcceptServerSpecifiedNumber ); |
|
1968 } |
|
1969 else |
|
1970 { |
|
1971 iApItem->WriteUint( EApIspIfCallbackType, |
|
1972 ECallbackActionMSCBCPRequireClientSpecifiedNumber ); |
|
1973 } |
|
1974 break; |
|
1975 } |
|
1976 case EApGprsPdpType: |
|
1977 { |
|
1978 TUint32 ipnettype( 0 ); |
|
1979 iApItem->ReadUint( EApGprsPdpType, ipnettype ); |
|
1980 if ( ipnettype == EIPv6 ) |
|
1981 { |
|
1982 iApItem->WriteUint( EApGprsPdpType, EIPv4 ); |
|
1983 } |
|
1984 else |
|
1985 { |
|
1986 iApItem->WriteUint( EApGprsPdpType, EIPv6 ); |
|
1987 } |
|
1988 break; |
|
1989 } |
|
1990 case EApWlanNetworkMode: |
|
1991 { |
|
1992 TUint32 netmode( 0 ); |
|
1993 iApItem->ReadUint( EApWlanNetworkMode, netmode ); |
|
1994 if ( netmode == EAdhoc ) |
|
1995 { |
|
1996 iApItem->WriteUint( EApWlanNetworkMode, EInfra ); |
|
1997 } |
|
1998 else |
|
1999 { |
|
2000 iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); |
|
2001 LimitSecMode(); |
|
2002 } |
|
2003 break; |
|
2004 } |
|
2005 case EApWapWspOption: |
|
2006 { |
|
2007 TUint32 intvar; |
|
2008 if ( iApItem->ReadUint( aDataMember, intvar ) == KErrNone ) |
|
2009 { |
|
2010 if ( intvar == EWapWspOptionConnectionless ) |
|
2011 { |
|
2012 intvar = EWapWspOptionConnectionOriented; |
|
2013 } |
|
2014 else |
|
2015 { |
|
2016 intvar = EWapWspOptionConnectionless; |
|
2017 } |
|
2018 iApItem->WriteUint( aDataMember, intvar ); |
|
2019 } |
|
2020 break; |
|
2021 } |
|
2022 default: |
|
2023 { |
|
2024 TBool bvar; |
|
2025 if ( iApItem->ReadBool( aDataMember, bvar ) == KErrNone ) |
|
2026 { |
|
2027 bvar = !bvar; |
|
2028 iApItem->WriteBool( aDataMember, bvar ); |
|
2029 } |
|
2030 } |
|
2031 } |
|
2032 |
|
2033 APSETUILOGGER_LEAVEFN( ESettings,"Settings::InvertSettingsL") |
|
2034 } |
|
2035 |
|
2036 |
|
2037 //---------------------------------------------------------- |
|
2038 // CApSettingsDlg::ShowPopupSettingPageL |
|
2039 //---------------------------------------------------------- |
|
2040 // |
|
2041 TBool CApSettingsDlg::ShowPopupSettingPageL( TApMember aData ) |
|
2042 { |
|
2043 APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupSettingPageL") |
|
2044 |
|
2045 TInt currvalue( 0 ); |
|
2046 TBool retval( EFalse ); |
|
2047 TBool mustrepeat( EFalse ); |
|
2048 |
|
2049 CDesCArrayFlat* items = FillPopupSettingPageLC( aData, currvalue ); |
|
2050 |
|
2051 TInt attr_resid( 0 ); |
|
2052 GetResId( aData, attr_resid ); |
|
2053 |
|
2054 do |
|
2055 { |
|
2056 HBufC* titlebuf; |
|
2057 CAknRadioButtonSettingPage* dlg; |
|
2058 if ( attr_resid ) |
|
2059 { |
|
2060 titlebuf = iEikonEnv->AllocReadResourceLC( attr_resid ); |
|
2061 dlg = new ( ELeave )CAknRadioButtonSettingPage( |
|
2062 R_RADIO_BUTTON_SETTING_PAGE, |
|
2063 currvalue, |
|
2064 items ); |
|
2065 // must push 'cause SetSettingTextL can leave... |
|
2066 CleanupStack::PushL( dlg ); |
|
2067 TPtrC ptr( titlebuf->Des() ); |
|
2068 dlg->SetSettingTextL( ptr ); |
|
2069 CleanupStack::Pop(); // dlg |
|
2070 } |
|
2071 else |
|
2072 { |
|
2073 dlg = new ( ELeave )CAknRadioButtonSettingPage( |
|
2074 R_RADIO_BUTTON_SETTING_PAGE, |
|
2075 currvalue, |
|
2076 items ); |
|
2077 } |
|
2078 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) |
|
2079 { |
|
2080 if( AskQueryIfWcdmaL( aData , currvalue) ) |
|
2081 { |
|
2082 UpdateFromPopupSettingPageL( aData, currvalue ); |
|
2083 retval = ETrue; |
|
2084 mustrepeat = EFalse; |
|
2085 } |
|
2086 else |
|
2087 { |
|
2088 mustrepeat = ETrue; |
|
2089 } |
|
2090 } |
|
2091 else |
|
2092 { |
|
2093 mustrepeat = EFalse; |
|
2094 } |
|
2095 if ( attr_resid ) |
|
2096 { |
|
2097 // titlebuf, text title readed from resource... |
|
2098 CleanupStack::PopAndDestroy(); |
|
2099 } |
|
2100 }while( mustrepeat ); |
|
2101 |
|
2102 |
|
2103 // items, will also delete all elements in the array! |
|
2104 CleanupStack::PopAndDestroy( items ); |
|
2105 |
|
2106 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupSettingPageL") |
|
2107 return retval; |
|
2108 } |
|
2109 |
|
2110 |
|
2111 |
|
2112 |
|
2113 |
|
2114 |
|
2115 |
|
2116 //---------------------------------------------------------- |
|
2117 // CApSettingsDlg::ShowPopupTextSettingPageL |
|
2118 //---------------------------------------------------------- |
|
2119 // |
|
2120 TBool CApSettingsDlg::ShowPopupTextSettingPageL( TApMember aData ) |
|
2121 { |
|
2122 APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupTextSettingPageL") |
|
2123 |
|
2124 TBool retval( EFalse ); |
|
2125 |
|
2126 // must be prepared for the worst case... |
|
2127 TBuf<KModifiableLongTextLength> textToChange; |
|
2128 |
|
2129 HBufC* aBuf1 = GetTextLC( aData ); |
|
2130 |
|
2131 HBufC* aBuf = ConvertPerNToDelimLC( aBuf1->Des() ); |
|
2132 |
|
2133 TPtr16 ptr( aBuf->Des() ); |
|
2134 textToChange.Append( ptr ); |
|
2135 |
|
2136 TInt page_resid( 0 ); |
|
2137 TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); |
|
2138 GetTextResId( aData, page_resid, TextSettingPageFlags ); |
|
2139 |
|
2140 |
|
2141 TBool isLatin ( aData == EApWapStartPage ); |
|
2142 |
|
2143 CAccessPointTextSettingPage* dlg = |
|
2144 new( ELeave )CAccessPointTextSettingPage( page_resid, textToChange, |
|
2145 TextSettingPageFlags, |
|
2146 isLatin ); |
|
2147 |
|
2148 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) |
|
2149 { |
|
2150 switch ( aData ) |
|
2151 { |
|
2152 case EApWapStartPage: |
|
2153 case EApGprsAccessPointName: |
|
2154 case EApIspLoginScript: |
|
2155 case EApIspInitString: |
|
2156 case EApWapAccessPointName: |
|
2157 case EApIspLoginName: |
|
2158 case EApIspLoginPass: |
|
2159 case EApIspIfAuthName: |
|
2160 case EApIspIfAuthPass: |
|
2161 { |
|
2162 HBufC* tmp = ConvertDelimToPerNLC( textToChange ); |
|
2163 textToChange.Zero(); |
|
2164 textToChange.Append( tmp->Des() ); |
|
2165 CleanupStack::PopAndDestroy( tmp ); |
|
2166 break; |
|
2167 } |
|
2168 case EApProxyServerAddress: |
|
2169 { |
|
2170 textToChange.Trim(); |
|
2171 break; |
|
2172 } |
|
2173 default: |
|
2174 { // no need for conversion |
|
2175 break; |
|
2176 } |
|
2177 } |
|
2178 if ( ( aData == EApIspLoginScript ) || ( aData == EApWapStartPage ) |
|
2179 || ( aData == EApGprsAccessPointName ) |
|
2180 || ( aData == EApProxyServerAddress ) ) |
|
2181 { |
|
2182 iApItem->WriteLongTextL( aData, textToChange ); |
|
2183 } |
|
2184 else |
|
2185 { |
|
2186 if ( aData == EApProxyPortNumber ) |
|
2187 { |
|
2188 // first remove non-number chars |
|
2189 HBufC* num = StripNonNumberLC( textToChange ); |
|
2190 textToChange.Zero(); |
|
2191 textToChange.Append( num->Des() ); |
|
2192 CleanupStack::PopAndDestroy( num ); |
|
2193 // and now get real numberic value |
|
2194 TInt tempint; |
|
2195 TLex lex; |
|
2196 lex.Assign( textToChange ); |
|
2197 if ( lex.Val( tempint ) ) |
|
2198 { // this means some error, set it to 0 |
|
2199 tempint = 0; |
|
2200 } |
|
2201 iApItem->WriteUint( EApProxyPortNumber, tempint ); |
|
2202 } |
|
2203 else |
|
2204 { |
|
2205 if ( ( aData == EApIspInitString ) ) |
|
2206 { |
|
2207 // must be prepared for the worst case... |
|
2208 TBuf8<KModifiableLongTextLength> textToChange8; |
|
2209 textToChange8.Copy( textToChange ); |
|
2210 iApItem->WriteTextL( aData, textToChange8 ); |
|
2211 } |
|
2212 else |
|
2213 { |
|
2214 if ( aData == EApWapAccessPointName ) |
|
2215 { |
|
2216 iApItem->SetNamesL( textToChange ); |
|
2217 } |
|
2218 else |
|
2219 { |
|
2220 iApItem->WriteTextL( aData, textToChange ); |
|
2221 } |
|
2222 } |
|
2223 } |
|
2224 } |
|
2225 retval = ETrue; |
|
2226 } |
|
2227 *iEventStore |= KApUiEventEdited; |
|
2228 CleanupStack::PopAndDestroy( 2 ); // aBuf, aBuf1 |
|
2229 |
|
2230 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupTextSettingPageL") |
|
2231 return retval; |
|
2232 } |
|
2233 |
|
2234 |
|
2235 |
|
2236 //---------------------------------------------------------- |
|
2237 // CApSettingsDlg::GetTextLC |
|
2238 //---------------------------------------------------------- |
|
2239 // |
|
2240 HBufC* CApSettingsDlg::GetTextLC( TApMember aData ) |
|
2241 { |
|
2242 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetTextLC") |
|
2243 |
|
2244 HBufC* ret; |
|
2245 switch ( aData ) |
|
2246 { |
|
2247 case EApWapStartPage: |
|
2248 { // Long text !!! |
|
2249 if ( iApItem->ReadTextLengthL( aData ) ) |
|
2250 { |
|
2251 // allocates as much as needed... |
|
2252 ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); |
|
2253 } |
|
2254 else |
|
2255 { |
|
2256 ret = iEikonEnv->AllocReadResourceLC( |
|
2257 R_APUI_VIEW_WAP_START_PAGE_DEFAULT ); |
|
2258 } |
|
2259 break; |
|
2260 } |
|
2261 case EApGprsAccessPointName: |
|
2262 { |
|
2263 // allocates as much as needed... |
|
2264 ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); |
|
2265 break; |
|
2266 } |
|
2267 case EApIspLoginScript: |
|
2268 { |
|
2269 // allocates as much as needed... |
|
2270 ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); |
|
2271 break; |
|
2272 } |
|
2273 case EApProxyServerAddress: |
|
2274 { |
|
2275 // allocates as much as needed... |
|
2276 ret = iApItem->ReadConstLongTextL( aData )->AllocLC(); |
|
2277 break; |
|
2278 } |
|
2279 case EApWapGatewayAddress: |
|
2280 case EApIspIPAddr: |
|
2281 case EApIspIPNetMask: |
|
2282 case EApWlanIpNetMask: |
|
2283 case EApIspIPGateway: |
|
2284 case EApWlanIpGateway: |
|
2285 case EApGprsIPNameServer1: |
|
2286 case EApIspIPNameServer1: |
|
2287 case EApGprsIPNameServer2: |
|
2288 case EApIspIPNameServer2: |
|
2289 { |
|
2290 ret = HBufC::NewLC( KModifiableTextLength ); |
|
2291 TPtr16 ptr( ret->Des() ); |
|
2292 iApItem->ReadTextL( aData, ptr ); |
|
2293 if ( ptr.Compare( KEmptyText ) == 0 ) |
|
2294 { |
|
2295 *ret = KDynIpAddress; |
|
2296 } |
|
2297 break; |
|
2298 } |
|
2299 case EApIspInitString: |
|
2300 { |
|
2301 ret = HBufC::NewLC( KModifiableTextLength ); |
|
2302 HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); |
|
2303 TPtr8 ptr( tmpValue8->Des() ); |
|
2304 iApItem->ReadTextL( aData, ptr ); |
|
2305 ret->Des().Copy( ptr ); |
|
2306 CleanupStack::PopAndDestroy(); // tmpValue8 |
|
2307 break; |
|
2308 } |
|
2309 case EApProxyPortNumber: |
|
2310 { |
|
2311 TUint32 tempint; |
|
2312 iApItem->ReadUint( EApProxyPortNumber, tempint ); |
|
2313 ret = HBufC::NewLC( KMaxProxyPortNumberLength ); |
|
2314 TPtr itemTextPtr = ret->Des(); |
|
2315 itemTextPtr.Format( KTxtNumber, tempint ); |
|
2316 break; |
|
2317 } |
|
2318 default: |
|
2319 { |
|
2320 ret = HBufC::NewLC( KModifiableTextLength ); |
|
2321 TPtr16 ptr( ret->Des() ); |
|
2322 iApItem->ReadTextL( aData, ptr ); |
|
2323 break; |
|
2324 } |
|
2325 } |
|
2326 |
|
2327 switch ( aData ) |
|
2328 { |
|
2329 case EApWapStartPage: |
|
2330 case EApGprsAccessPointName: |
|
2331 case EApIspLoginScript: |
|
2332 case EApIspInitString: |
|
2333 case EApWapAccessPointName: |
|
2334 case EApIspLoginName: |
|
2335 case EApIspLoginPass: |
|
2336 case EApIspIfAuthName: |
|
2337 case EApIspIfAuthPass: |
|
2338 { |
|
2339 break; |
|
2340 } |
|
2341 default: |
|
2342 { |
|
2343 // nothing to do |
|
2344 break; |
|
2345 } |
|
2346 } |
|
2347 |
|
2348 |
|
2349 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetTextLC") |
|
2350 return ret; |
|
2351 } |
|
2352 |
|
2353 |
|
2354 //---------------------------------------------------------- |
|
2355 // CApSettingsDlg::GetTextResId |
|
2356 //---------------------------------------------------------- |
|
2357 // |
|
2358 void CApSettingsDlg::GetTextResId( TApMember aData, TInt& apage, |
|
2359 TInt& aTextSettingPageFlags ) |
|
2360 { |
|
2361 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetTextResId") |
|
2362 |
|
2363 if ( ( aData != EApWapAccessPointName ) |
|
2364 && ( aData != EApIspDefaultTelNumber ) ) |
|
2365 { |
|
2366 aTextSettingPageFlags |= CAknTextSettingPage::EZeroLengthAllowed; |
|
2367 } |
|
2368 else |
|
2369 { |
|
2370 aTextSettingPageFlags &= (~CAknTextSettingPage::EZeroLengthAllowed); |
|
2371 } |
|
2372 |
|
2373 switch ( aData ) |
|
2374 { |
|
2375 case EApIspInitString: |
|
2376 { |
|
2377 apage = R_TEXT_SETTING_PAGE_MODEM_INIT_STRING; |
|
2378 break; |
|
2379 } |
|
2380 case EApWapAccessPointName: |
|
2381 { |
|
2382 apage = R_TEXT_SETTING_PAGE_CONN_NAME; |
|
2383 break; |
|
2384 } |
|
2385 case EApGprsAccessPointName: |
|
2386 { |
|
2387 apage = R_TEXT_SETTING_PAGE_GPRSAP_NAME; |
|
2388 break; |
|
2389 } |
|
2390 case EApIspLoginScript:// use EDWIN for script. |
|
2391 { |
|
2392 apage = R_TEXT_SETTING_PAGE_LOGIN_SCRIPT; |
|
2393 break; |
|
2394 } |
|
2395 case EApIspLoginName: |
|
2396 case EApIspIfAuthName: |
|
2397 { |
|
2398 apage = R_TEXT_SETTING_PAGE_LOGIN_NAME; |
|
2399 break; |
|
2400 } |
|
2401 case EApWapStartPage: |
|
2402 { |
|
2403 apage = R_TEXT_SETTING_PAGE_STARTING_PAGE; |
|
2404 break; |
|
2405 } |
|
2406 // use EDWINS as no such thing as PhoneNumber editor... |
|
2407 case EApIspDefaultTelNumber: |
|
2408 { |
|
2409 apage = R_TEXT_SETTING_PAGE_ACCESS_NUM; |
|
2410 break; |
|
2411 } |
|
2412 case EApIspIfCallbackInfo: |
|
2413 { |
|
2414 apage = R_TEXT_SETTING_PAGE_CB_NUM; |
|
2415 break; |
|
2416 } |
|
2417 case EApWapGatewayAddress: |
|
2418 { |
|
2419 apage = R_TEXT_SETTING_PAGE_GW_ADDR; |
|
2420 break; |
|
2421 } |
|
2422 case EApProxyServerAddress: |
|
2423 { |
|
2424 apage = R_TEXT_SETTING_PAGE_PROXY_SERVER_ADDR; |
|
2425 break; |
|
2426 } |
|
2427 case EApProxyPortNumber: |
|
2428 { |
|
2429 apage = R_TEXT_SETTING_PAGE_PROXY_PORT_NUMBER; |
|
2430 break; |
|
2431 } |
|
2432 case EApIspIPAddr: |
|
2433 { |
|
2434 apage = R_TEXT_SETTING_PAGE_ISPIP_ADDR; |
|
2435 break; |
|
2436 } |
|
2437 case EApIspIPNetMask: |
|
2438 case EApWlanIpNetMask: |
|
2439 { |
|
2440 apage = R_TEXT_SETTING_PAGE_ISP_NET_MASK; |
|
2441 break; |
|
2442 } |
|
2443 case EApIspIPGateway: |
|
2444 case EApWlanIpGateway: |
|
2445 { |
|
2446 apage = R_TEXT_SETTING_PAGE_ISP_GATEWAY; |
|
2447 break; |
|
2448 } |
|
2449 case EApGprsIPNameServer1: |
|
2450 case EApIspIPNameServer1: |
|
2451 { |
|
2452 apage = R_TEXT_SETTING_PAGE_NAME_SERV1; |
|
2453 break; |
|
2454 } |
|
2455 case EApGprsIPNameServer2: |
|
2456 case EApIspIPNameServer2: |
|
2457 { |
|
2458 apage = R_TEXT_SETTING_PAGE_NAME_SERV2; |
|
2459 break; |
|
2460 } |
|
2461 case EApIspLoginPass: |
|
2462 case EApIspIfAuthPass: |
|
2463 { // use EEikCtSecretEd |
|
2464 apage = R_TEXT_SETTING_PAGE_LOGIN_PASSWD; |
|
2465 break; |
|
2466 } |
|
2467 |
|
2468 case EApIspUseLoginScript: |
|
2469 {// use EDWIN: |
|
2470 apage = R_SETTING_APP_EDWIN_LOGIN_SCRIPT; |
|
2471 break; |
|
2472 } |
|
2473 case EApWlanNetworkName: |
|
2474 { |
|
2475 apage = R_TEXT_SETTING_PAGE_NETW_NAME; |
|
2476 break; |
|
2477 } |
|
2478 default: |
|
2479 { |
|
2480 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
2481 apage = 0; |
|
2482 break; |
|
2483 } |
|
2484 } |
|
2485 |
|
2486 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetTextResId") |
|
2487 } |
|
2488 |
|
2489 |
|
2490 |
|
2491 //---------------------------------------------------------- |
|
2492 // CApSettingsDlg::GetResId |
|
2493 //---------------------------------------------------------- |
|
2494 // |
|
2495 void CApSettingsDlg::GetResId( TApMember aData, TInt& aattr ) |
|
2496 { |
|
2497 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetResId") |
|
2498 |
|
2499 // not text based ones: |
|
2500 switch ( aData ) |
|
2501 { |
|
2502 case EApWapCurrentBearer: |
|
2503 { |
|
2504 aattr = R_APUI_VIEW_BEARER_TYPE; |
|
2505 break; |
|
2506 } |
|
2507 case EApWapSecurity: |
|
2508 { |
|
2509 aattr = R_APUI_VIEW_WTLS_SECURITY; |
|
2510 break; |
|
2511 } |
|
2512 case EApWapWspOption: |
|
2513 { |
|
2514 aattr = R_APUI_VIEW_CONNECTION_TYPE; |
|
2515 break; |
|
2516 } |
|
2517 case EApIspPromptForLogin: |
|
2518 { |
|
2519 aattr = R_APUI_VIEW_PROMPT_PASSWORD; |
|
2520 break; |
|
2521 } |
|
2522 case EApGprsDisablePlainTextAuth: |
|
2523 case EApIspDisablePlainTextAuth: |
|
2524 { |
|
2525 aattr = R_APUI_VIEW_PASSWORD_AUTH; |
|
2526 break; |
|
2527 } |
|
2528 case EApIspBearerCallTypeIsdn: // used for data call type |
|
2529 { |
|
2530 aattr = R_APUI_VIEW_DATA_CALL_TYPE; |
|
2531 break; |
|
2532 } |
|
2533 case EApIspBearerSpeed: |
|
2534 { |
|
2535 aattr = R_APUI_VIEW_MAX_CONN_SPEED; |
|
2536 break; |
|
2537 } |
|
2538 case EApIspIfCallbackEnabled: |
|
2539 { |
|
2540 aattr = R_APUI_VIEW_USE_CALL_BACK; |
|
2541 break; |
|
2542 } |
|
2543 case EApIspIfCallbackType: |
|
2544 { |
|
2545 aattr = R_APUI_VIEW_CALL_BACK_TYPE; |
|
2546 break; |
|
2547 } |
|
2548 case EApIspEnableSWCompression: |
|
2549 case EApGprsHeaderCompression: |
|
2550 { |
|
2551 aattr = R_APUI_VIEW_ENABLE_PPP_COMP; |
|
2552 break; |
|
2553 } |
|
2554 case EApIspInitString: |
|
2555 { |
|
2556 aattr = R_APUI_VIEW_MODEM_INIT_STRING; |
|
2557 break; |
|
2558 } |
|
2559 case EApIspUseLoginScript: |
|
2560 { |
|
2561 aattr = R_APUI_VIEW_USE_LOGIN_SCRIPT; |
|
2562 break; |
|
2563 } |
|
2564 case EApGprsPdpType: |
|
2565 { |
|
2566 aattr = R_APUI_VIEW_PDP_TYPE; |
|
2567 break; |
|
2568 } |
|
2569 case EApIP6DNSAddrFromServer: |
|
2570 { |
|
2571 aattr = R_APUI_VIEW_SET_DNS_SERVERS_IP; |
|
2572 break; |
|
2573 } |
|
2574 case EApWlanNetworkName: |
|
2575 { |
|
2576 aattr = R_APUI_VIEW_WLAN_NETWORK_NAME; |
|
2577 break; |
|
2578 } |
|
2579 case EApWlanNetworkMode: |
|
2580 { |
|
2581 aattr = R_APUI_VIEW_WLAN_NETWORK_MODE; |
|
2582 break; |
|
2583 } |
|
2584 case EApWlanSecurityMode: |
|
2585 { |
|
2586 aattr = R_APUI_VIEW_WLAN_SECURITY_MODE; |
|
2587 break; |
|
2588 } |
|
2589 case EApWlanScanSSID: |
|
2590 { |
|
2591 aattr = R_APUI_VIEW_WLAN_HIDDEN_NETWORK; |
|
2592 break; |
|
2593 } |
|
2594 case EApWlanChannelId: |
|
2595 { |
|
2596 aattr = R_APUI_VIEW_AD_HOC; |
|
2597 break; |
|
2598 } |
|
2599 default: |
|
2600 { |
|
2601 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
2602 aattr = 0; |
|
2603 break; |
|
2604 } |
|
2605 } |
|
2606 |
|
2607 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetResId") |
|
2608 } |
|
2609 |
|
2610 |
|
2611 |
|
2612 |
|
2613 // --------------------------------------------------------- |
|
2614 // CApSettingsDlg::FillPopupSettingPageL |
|
2615 // --------------------------------------------------------- |
|
2616 // |
|
2617 CDesCArrayFlat* CApSettingsDlg::FillPopupSettingPageLC( TApMember aData, |
|
2618 TInt& aCurrvalue ) |
|
2619 { |
|
2620 APSETUILOGGER_ENTERFN( ESettings,"Settings::FillPopupSettingPageLC") |
|
2621 |
|
2622 CDesCArrayFlat* items = new( ELeave)CDesCArrayFlat( 1 ); |
|
2623 CleanupStack::PushL( items ); |
|
2624 |
|
2625 TUint32 tval( 0 ); |
|
2626 |
|
2627 switch ( aData ) |
|
2628 { |
|
2629 case EApIspPromptForLogin: |
|
2630 { |
|
2631 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2632 R_APUI_VIEW_PROMPT_PASSWD_YES ) ); |
|
2633 CleanupStack::PopAndDestroy(); |
|
2634 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2635 R_APUI_VIEW_PROMPT_PASSWD_NO ) ); |
|
2636 CleanupStack::PopAndDestroy(); |
|
2637 GetBoolDataValue( aData, ETrue, aCurrvalue ); |
|
2638 break; |
|
2639 } |
|
2640 case EApWapSecurity: |
|
2641 { |
|
2642 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2643 R_APUI_VIEW_WTLS_SECURITY_ON ) ); |
|
2644 CleanupStack::PopAndDestroy(); |
|
2645 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2646 R_APUI_VIEW_WTLS_SECURITY_OFF ) ); |
|
2647 CleanupStack::PopAndDestroy(); |
|
2648 GetBoolDataValue( aData, ETrue, aCurrvalue ); |
|
2649 break; |
|
2650 } |
|
2651 case EApIspIfCallbackEnabled: |
|
2652 { |
|
2653 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2654 R_APUI_VIEW_USE_CB_YES ) ); |
|
2655 CleanupStack::PopAndDestroy(); |
|
2656 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2657 R_APUI_VIEW_USE_CB_NO ) ); |
|
2658 CleanupStack::PopAndDestroy(); |
|
2659 GetBoolDataValue( aData, ETrue, aCurrvalue ); |
|
2660 break; |
|
2661 } |
|
2662 case EApIspEnableSWCompression: |
|
2663 case EApGprsHeaderCompression: |
|
2664 { |
|
2665 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2666 R_APUI_VIEW_PPP_COMP_YES ) ); |
|
2667 CleanupStack::PopAndDestroy(); |
|
2668 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2669 R_APUI_VIEW_PPP_COMP_NO ) ); |
|
2670 CleanupStack::PopAndDestroy(); |
|
2671 GetBoolDataValue( aData, ETrue, aCurrvalue ); |
|
2672 break; |
|
2673 } |
|
2674 case EApWapCurrentBearer: |
|
2675 { |
|
2676 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2677 R_APUI_VIEW_BEARER_TYPE_GPRS ) ); |
|
2678 CleanupStack::PopAndDestroy(); |
|
2679 |
|
2680 if ( IsWlanSupported() ) |
|
2681 { |
|
2682 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2683 R_APUI_VIEW_BEARER_TYPE_WLAN ) ); |
|
2684 CleanupStack::PopAndDestroy(); |
|
2685 } |
|
2686 |
|
2687 TBool isCsdSupported = |
|
2688 FeatureManager::FeatureSupported( KFeatureIdAppCsdSupport ); |
|
2689 #ifdef __TEST_CSD_SUPPORT |
|
2690 isCsdSupported = ETrue; |
|
2691 #endif // __TEST_CSD_SUPPORT |
|
2692 |
|
2693 if ( isCsdSupported ) |
|
2694 { |
|
2695 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2696 R_APUI_VIEW_BEARER_TYPE_CSD ) ); |
|
2697 CleanupStack::PopAndDestroy(); |
|
2698 |
|
2699 if ( IsHSCSDEnabledL() ) |
|
2700 { |
|
2701 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2702 R_APUI_VIEW_BEARER_TYPE_HSCSD ) ); |
|
2703 CleanupStack::PopAndDestroy(); |
|
2704 } |
|
2705 } |
|
2706 aCurrvalue = BearerType2BearerItemPosL( iBearerType ); |
|
2707 break; |
|
2708 } |
|
2709 case EApGprsDisablePlainTextAuth: |
|
2710 case EApIspDisablePlainTextAuth: |
|
2711 { |
|
2712 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2713 R_APUI_VIEW_PASSWORD_AUTH_NORMAL ) ); |
|
2714 CleanupStack::PopAndDestroy(); |
|
2715 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2716 R_APUI_VIEW_PASSWORD_AUTH_SECURE ) ); |
|
2717 CleanupStack::PopAndDestroy(); |
|
2718 GetBoolDataValue( aData, EFalse, aCurrvalue ); |
|
2719 // needs to be inverted? |
|
2720 break; |
|
2721 } |
|
2722 case EApWapWspOption: |
|
2723 { |
|
2724 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2725 R_APUI_VIEW_CONN_TYPE_CONTIN ) ); |
|
2726 CleanupStack::PopAndDestroy(); |
|
2727 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2728 R_APUI_VIEW_CONN_TYPE_TEMP ) ); |
|
2729 CleanupStack::PopAndDestroy(); |
|
2730 iApItem->ReadUint( aData, tval ); |
|
2731 aCurrvalue = Min( 1, tval ); |
|
2732 aCurrvalue = !aCurrvalue; |
|
2733 break; |
|
2734 } |
|
2735 case EApIspBearerCallTypeIsdn: // used for data call type |
|
2736 { |
|
2737 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2738 R_APUI_VIEW_DATACALL_ANALOLGUE ) ); |
|
2739 CleanupStack::PopAndDestroy(); |
|
2740 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2741 R_APUI_VIEW_DATACALL_ISDN_110 ) ); |
|
2742 CleanupStack::PopAndDestroy(); |
|
2743 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2744 R_APUI_VIEW_DATACALL_ISDN_120 ) ); |
|
2745 CleanupStack::PopAndDestroy(); |
|
2746 iApItem->ReadUint( EApIspBearerCallTypeIsdn, tval ); |
|
2747 switch ( tval ) |
|
2748 { |
|
2749 case ECallTypeISDNv110: |
|
2750 { |
|
2751 aCurrvalue = KIspCallIsdn110; |
|
2752 break; |
|
2753 } |
|
2754 case ECallTypeISDNv120: |
|
2755 { |
|
2756 aCurrvalue = KIspCallIsdn120; |
|
2757 break; |
|
2758 } |
|
2759 default: |
|
2760 case ECallTypeAnalogue: |
|
2761 { |
|
2762 aCurrvalue = KIspCallAnalogue; |
|
2763 break; |
|
2764 } |
|
2765 } |
|
2766 break; |
|
2767 } |
|
2768 case EApIspBearerSpeed: |
|
2769 { |
|
2770 FillUpBearerSpeedValuesL( *items, aCurrvalue ); |
|
2771 break; |
|
2772 } |
|
2773 case EApIspIfCallbackType: |
|
2774 { |
|
2775 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2776 R_APUI_VIEW_CB_USE_SERVER_NUMBER ) ); |
|
2777 CleanupStack::PopAndDestroy(); |
|
2778 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2779 R_APUI_VIEW_CB_USE_OTHER_NUMBER ) ); |
|
2780 CleanupStack::PopAndDestroy(); |
|
2781 iApItem->ReadUint( aData, tval ); |
|
2782 if ( tval == ECallbackActionMSCBCPRequireClientSpecifiedNumber ) |
|
2783 { |
|
2784 aCurrvalue = 1; |
|
2785 } |
|
2786 else |
|
2787 { |
|
2788 aCurrvalue = 0; |
|
2789 } |
|
2790 break; |
|
2791 } |
|
2792 case EApIspUseLoginScript: |
|
2793 { |
|
2794 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2795 R_APUI_VIEW_USE_LOGINS_YES ) ); |
|
2796 CleanupStack::PopAndDestroy(); |
|
2797 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2798 R_APUI_VIEW_USE_LOGINS_NO ) ); |
|
2799 CleanupStack::PopAndDestroy(); |
|
2800 GetBoolDataValue( aData, ETrue, aCurrvalue ); |
|
2801 break; |
|
2802 } |
|
2803 case EApGprsPdpType: |
|
2804 { |
|
2805 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2806 R_APUI_VIEW_PDP_TYPE_IPV4 ) ); |
|
2807 CleanupStack::PopAndDestroy(); |
|
2808 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2809 R_APUI_VIEW_PDP_TYPE_IPV6 ) ); |
|
2810 CleanupStack::PopAndDestroy(); |
|
2811 iApItem->ReadUint( aData, tval ); |
|
2812 if ( tval == EIPv6 ) |
|
2813 { |
|
2814 aCurrvalue = 1; |
|
2815 } |
|
2816 else |
|
2817 { |
|
2818 aCurrvalue = 0; |
|
2819 } |
|
2820 break; |
|
2821 } |
|
2822 case EApIP6DNSAddrFromServer: |
|
2823 { |
|
2824 TApBearerType b = iApItem->BearerTypeL(); |
|
2825 TBool hasAuto = ( b != EApBearerTypeCSD ) |
|
2826 && ( b != EApBearerTypeHSCSD ) ; |
|
2827 if ( hasAuto ) |
|
2828 { |
|
2829 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2830 R_APUI_VIEW_NEW_AP_DNS_SERVERS_AUTOMATIC ) ); |
|
2831 CleanupStack::PopAndDestroy(); |
|
2832 } |
|
2833 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2834 R_APUI_VIEW_SET_IP_WELL_KNOWN ) ); |
|
2835 CleanupStack::PopAndDestroy(); |
|
2836 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2837 R_APUI_VIEW_SET_IP_USER_DEFINED ) ); |
|
2838 CleanupStack::PopAndDestroy(); |
|
2839 TBool bval; |
|
2840 iApItem->ReadBool( aData, bval ); |
|
2841 if ( !bval ) |
|
2842 { |
|
2843 aCurrvalue = GetIPv6DNSTypeL(); |
|
2844 if ( !hasAuto ) |
|
2845 { // no Auto item, dec. currvalue |
|
2846 aCurrvalue--; |
|
2847 } |
|
2848 } |
|
2849 else |
|
2850 { |
|
2851 aCurrvalue = 0; |
|
2852 } |
|
2853 break; |
|
2854 } |
|
2855 case EApWlanNetworkName: |
|
2856 { |
|
2857 if ( IsWlanSupported() ) |
|
2858 { |
|
2859 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2860 R_APUI_VIEW_WLAN_NETWORK_NAME_USER ) ); |
|
2861 CleanupStack::PopAndDestroy(); |
|
2862 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2863 R_APUI_VIEW_WLAN_NETWORK_NAME_SCAN ) ); |
|
2864 CleanupStack::PopAndDestroy(); |
|
2865 // set current value as user defined: if not yet given, |
|
2866 // it is true, if it had been already specified, |
|
2867 // we could not know if it was the user or was it scanned |
|
2868 aCurrvalue = 0; |
|
2869 } |
|
2870 else |
|
2871 { |
|
2872 User::Leave( KErrNotSupported ); |
|
2873 } |
|
2874 break; |
|
2875 } |
|
2876 case EApWlanNetworkMode: |
|
2877 { |
|
2878 if ( IsWlanSupported() ) |
|
2879 { |
|
2880 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2881 R_APUI_VIEW_WLAN_NETWORK_MODE_INFRA ) ); |
|
2882 CleanupStack::PopAndDestroy(); |
|
2883 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2884 R_APUI_VIEW_WLAN_NETWORK_MODE_ADHOC ) ); |
|
2885 CleanupStack::PopAndDestroy(); |
|
2886 iApItem->ReadUint( aData, tval ); |
|
2887 if ( tval == EAdhoc ) |
|
2888 { |
|
2889 aCurrvalue = 1; |
|
2890 } |
|
2891 else |
|
2892 { |
|
2893 aCurrvalue = 0; |
|
2894 } |
|
2895 } |
|
2896 else |
|
2897 { |
|
2898 User::Leave( KErrNotSupported ); |
|
2899 } |
|
2900 break; |
|
2901 } |
|
2902 case EApWlanScanSSID: |
|
2903 { |
|
2904 if ( IsWlanSupported() ) |
|
2905 { |
|
2906 TBool bval(EFalse); |
|
2907 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2908 R_APUI_VIEW_HIDDEN_NETWORK_NO ) ); |
|
2909 CleanupStack::PopAndDestroy(); |
|
2910 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2911 R_APUI_VIEW_HIDDEN_NETWORK_YES ) ); |
|
2912 CleanupStack::PopAndDestroy(); |
|
2913 iApItem->ReadBool( aData, bval ); |
|
2914 if ( bval ) |
|
2915 { |
|
2916 aCurrvalue = 1; |
|
2917 } |
|
2918 else |
|
2919 { |
|
2920 aCurrvalue = 0; |
|
2921 } |
|
2922 } |
|
2923 else |
|
2924 { |
|
2925 User::Leave( KErrNotSupported ); |
|
2926 } |
|
2927 break; |
|
2928 } |
|
2929 case EApWlanChannelId: |
|
2930 { |
|
2931 if ( IsWlanSupported() ) |
|
2932 { |
|
2933 TUint32 channel(0); |
|
2934 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2935 R_APUI_VIEW_AD_HOC_CHANNEL_AUTO ) ); |
|
2936 CleanupStack::PopAndDestroy(); |
|
2937 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2938 R_APUI_VIEW_AD_HOC_CHANNEL_USER_DEFINED ) ); |
|
2939 CleanupStack::PopAndDestroy(); |
|
2940 iApItem->ReadUint( aData, channel ); |
|
2941 if ( channel ) |
|
2942 { |
|
2943 aCurrvalue = 1; |
|
2944 } |
|
2945 else |
|
2946 { |
|
2947 aCurrvalue = 0; |
|
2948 } |
|
2949 } |
|
2950 else |
|
2951 { |
|
2952 User::Leave( KErrNotSupported ); |
|
2953 } |
|
2954 break; |
|
2955 } |
|
2956 case EApWlanSecurityMode: |
|
2957 { |
|
2958 if ( IsWlanSupported() ) |
|
2959 { |
|
2960 TUint32 netmode(0); |
|
2961 |
|
2962 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2963 R_APUI_VIEW_WLAN_SECURITY_MODE_OPEN ) ); |
|
2964 CleanupStack::PopAndDestroy(); |
|
2965 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2966 R_APUI_VIEW_WLAN_SECURITY_MODE_WEP ) ); |
|
2967 CleanupStack::PopAndDestroy(); |
|
2968 |
|
2969 iApItem->ReadUint( EApWlanNetworkMode, netmode ); |
|
2970 if ( netmode == EInfra ) |
|
2971 { |
|
2972 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2973 R_APUI_VIEW_WLAN_SECURITY_MODE_802_1X ) ); |
|
2974 CleanupStack::PopAndDestroy(); |
|
2975 items->AppendL( *iEikonEnv->AllocReadResourceLC( |
|
2976 R_APUI_VIEW_WLAN_SECURITY_MODE_WPA ) ); |
|
2977 CleanupStack::PopAndDestroy(); |
|
2978 } |
|
2979 |
|
2980 iApItem->ReadUint( aData, tval ); |
|
2981 switch ( tval ) |
|
2982 { |
|
2983 case EOpen: |
|
2984 { |
|
2985 aCurrvalue = 0; |
|
2986 break; |
|
2987 } |
|
2988 case EWep: |
|
2989 { |
|
2990 aCurrvalue = 1; |
|
2991 break; |
|
2992 } |
|
2993 case E802_1x: |
|
2994 { |
|
2995 aCurrvalue = 2; |
|
2996 if ( netmode != EInfra ) |
|
2997 { |
|
2998 aCurrvalue--; |
|
2999 } |
|
3000 break; |
|
3001 } |
|
3002 case EWpa: |
|
3003 case EWpa2: |
|
3004 { |
|
3005 aCurrvalue = 3; |
|
3006 if ( netmode != EInfra ) |
|
3007 { |
|
3008 aCurrvalue-= 2; |
|
3009 } |
|
3010 break; |
|
3011 } |
|
3012 default: |
|
3013 { |
|
3014 aCurrvalue = 0; |
|
3015 break; |
|
3016 } |
|
3017 } |
|
3018 } |
|
3019 else |
|
3020 { |
|
3021 User::Leave( KErrNotSupported ); |
|
3022 } |
|
3023 break; |
|
3024 } |
|
3025 default: |
|
3026 { |
|
3027 __ASSERT_DEBUG( EFalse, Panic ( EUnknownCase ) ); |
|
3028 User::Leave( KErrInvalidColumn ); |
|
3029 break; |
|
3030 } |
|
3031 } |
|
3032 |
|
3033 APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillPopupSettingPageLC") |
|
3034 return items; |
|
3035 } |
|
3036 |
|
3037 |
|
3038 |
|
3039 |
|
3040 // --------------------------------------------------------- |
|
3041 // CApSettingsDlg::UpdateFromPopupSettingPageL |
|
3042 // --------------------------------------------------------- |
|
3043 // |
|
3044 void CApSettingsDlg::UpdateFromPopupSettingPageL( TApMember aData, |
|
3045 TInt aCurrvalue ) |
|
3046 { |
|
3047 APSETUILOGGER_ENTERFN( ESettings,"Settings::UpdateFromPopupSettingPageL") |
|
3048 |
|
3049 switch ( aData ) |
|
3050 { |
|
3051 case EApWapSecurity: |
|
3052 case EApIspPromptForLogin: |
|
3053 case EApIspIfCallbackEnabled: |
|
3054 case EApIspEnableSWCompression: |
|
3055 case EApGprsHeaderCompression: |
|
3056 case EApIspUseLoginScript: |
|
3057 { // INVERTED! |
|
3058 iApItem->WriteBool( aData, !( TBool( aCurrvalue ) ) ); |
|
3059 break; |
|
3060 } |
|
3061 case EApWlanScanSSID: |
|
3062 case EApGprsDisablePlainTextAuth: |
|
3063 case EApIspDisablePlainTextAuth: |
|
3064 { // NOT INVERTED! |
|
3065 iApItem->WriteBool( aData, ( TBool( aCurrvalue ) ) ); |
|
3066 break; |
|
3067 } |
|
3068 case EApWapWspOption: |
|
3069 { |
|
3070 if ( aCurrvalue ) |
|
3071 { |
|
3072 iApItem->WriteUint( EApWapWspOption, |
|
3073 EWapWspOptionConnectionless ); |
|
3074 } |
|
3075 else |
|
3076 { |
|
3077 iApItem->WriteUint( EApWapWspOption, |
|
3078 EWapWspOptionConnectionOriented ); |
|
3079 } |
|
3080 break; |
|
3081 } |
|
3082 case EApWapCurrentBearer: |
|
3083 { |
|
3084 DoBearerChangeL( aCurrvalue ); |
|
3085 break; |
|
3086 } |
|
3087 case EApIspBearerSpeed: |
|
3088 { |
|
3089 iApItem->WriteUint( EApIspBearerSpeed, |
|
3090 GetBearerSpeedForSelection( aCurrvalue ) |
|
3091 ); |
|
3092 break; |
|
3093 } |
|
3094 case EApIspIfCallbackType: |
|
3095 { // UINT |
|
3096 if ( aCurrvalue ) |
|
3097 { |
|
3098 iApItem->WriteUint( EApIspIfCallbackType, |
|
3099 ECallbackActionMSCBCPRequireClientSpecifiedNumber ); |
|
3100 } |
|
3101 else |
|
3102 { |
|
3103 iApItem->WriteUint( EApIspIfCallbackType, |
|
3104 ECallbackActionMSCBCPAcceptServerSpecifiedNumber ); |
|
3105 } |
|
3106 break; |
|
3107 } |
|
3108 case EApIspBearerCallTypeIsdn: // used for data call type |
|
3109 { |
|
3110 // as order is the same in UI and in enum, simply write it |
|
3111 iApItem->WriteUint( EApIspBearerCallTypeIsdn, aCurrvalue ); |
|
3112 LimitSpeed(); |
|
3113 break; |
|
3114 } |
|
3115 case EApGprsPdpType: |
|
3116 { |
|
3117 // get value to write |
|
3118 if ( aCurrvalue ) |
|
3119 { |
|
3120 aCurrvalue = EIPv6; |
|
3121 } |
|
3122 else |
|
3123 { |
|
3124 aCurrvalue = EIPv4; |
|
3125 } |
|
3126 iApItem->WriteUint( EApGprsPdpType, aCurrvalue ); |
|
3127 break; |
|
3128 } |
|
3129 case EApIP6DNSAddrFromServer: |
|
3130 { |
|
3131 // if it is CSD or HSCSD, there is NO AUTOMATIC value, |
|
3132 // just the next two: Well-known & User defined... |
|
3133 // So in those cases, aCurrvalue must be 0 & 1, which |
|
3134 // corresponds to the normal 1, 2 so it should be incremented |
|
3135 TInt realvalue = aCurrvalue; |
|
3136 TApBearerType b = iApItem->BearerTypeL(); |
|
3137 if ( ( b == EApBearerTypeCSD ) || ( b == EApBearerTypeHSCSD ) ) |
|
3138 { |
|
3139 realvalue++; |
|
3140 } |
|
3141 |
|
3142 if ( realvalue == 2 ) |
|
3143 { // user defined!!! |
|
3144 TBool isip6( EFalse ); |
|
3145 if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) |
|
3146 { |
|
3147 TUint32 ival(0); |
|
3148 iApItem->ReadUint( EApGprsPdpType, ival ); |
|
3149 if ( ival == EIPv6 ) |
|
3150 { |
|
3151 isip6 = ETrue; |
|
3152 } |
|
3153 } |
|
3154 else |
|
3155 { |
|
3156 isip6 = !iL2Ipv4; |
|
3157 } |
|
3158 GetNameServersL( isip6 ); |
|
3159 } |
|
3160 else |
|
3161 { |
|
3162 if ( realvalue == 1 ) |
|
3163 { // well-known |
|
3164 // write default well known name server values |
|
3165 iApItem->WriteTextL( EApIP6NameServer1, |
|
3166 KKnownNameServer1 ); |
|
3167 iApItem->WriteTextL( EApIP6NameServer2, |
|
3168 KKnownNameServer2 ); |
|
3169 } |
|
3170 else |
|
3171 { |
|
3172 iApItem->WriteTextL( EApIP6NameServer1, KDynIpv6Address ); |
|
3173 iApItem->WriteTextL( EApIP6NameServer2, KDynIpv6Address ); |
|
3174 } |
|
3175 } |
|
3176 break; |
|
3177 } |
|
3178 case EApWlanNetworkMode: |
|
3179 { |
|
3180 if ( IsWlanSupported() ) |
|
3181 { |
|
3182 if ( aCurrvalue ) |
|
3183 { |
|
3184 iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); |
|
3185 LimitSecMode(); |
|
3186 } |
|
3187 else |
|
3188 { |
|
3189 iApItem->WriteUint( EApWlanNetworkMode, EInfra ); |
|
3190 } |
|
3191 |
|
3192 } |
|
3193 else |
|
3194 { |
|
3195 User::Leave( KErrNotSupported ); |
|
3196 } |
|
3197 break; |
|
3198 } |
|
3199 case EApWlanSecurityMode: |
|
3200 { |
|
3201 if ( IsWlanSupported() ) |
|
3202 { |
|
3203 TInt secmode(EOpen); |
|
3204 switch ( aCurrvalue ) |
|
3205 { |
|
3206 case KItemIndex0: |
|
3207 { |
|
3208 secmode = EOpen; |
|
3209 break; |
|
3210 } |
|
3211 case KItemIndex1: |
|
3212 { |
|
3213 secmode = EWep; |
|
3214 break; |
|
3215 } |
|
3216 case KItemIndex2: |
|
3217 { |
|
3218 secmode = E802_1x; |
|
3219 break; |
|
3220 } |
|
3221 case KItemIndex3: |
|
3222 { |
|
3223 secmode = EWpa; |
|
3224 break; |
|
3225 } |
|
3226 default: |
|
3227 { |
|
3228 secmode = EOpen; |
|
3229 break; |
|
3230 } |
|
3231 } |
|
3232 iApItem->WriteUint( EApWlanSecurityMode, secmode ); |
|
3233 } |
|
3234 else |
|
3235 { |
|
3236 User::Leave( KErrNotSupported ); |
|
3237 } |
|
3238 break; |
|
3239 } |
|
3240 case EApWlanChannelId: |
|
3241 { |
|
3242 if ( IsWlanSupported() ) |
|
3243 { |
|
3244 if ( aCurrvalue ) |
|
3245 { // user defined, ask number from user, offer 7 as default |
|
3246 TUint32 channel = GetAdHocChannelL(); |
|
3247 iApItem->WriteUint( EApWlanChannelId, channel ); |
|
3248 } |
|
3249 else |
|
3250 { // auto, write 0 |
|
3251 iApItem->WriteUint( EApWlanChannelId, aCurrvalue ); |
|
3252 } |
|
3253 } |
|
3254 else |
|
3255 { |
|
3256 User::Leave( KErrNotSupported ); |
|
3257 } |
|
3258 break; |
|
3259 } |
|
3260 default: |
|
3261 { |
|
3262 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
3263 User::Leave( KErrInvalidColumn ); |
|
3264 break; |
|
3265 } |
|
3266 } |
|
3267 |
|
3268 APSETUILOGGER_LEAVEFN( ESettings,"Settings::UpdateFromPopupSettingPageL") |
|
3269 } |
|
3270 |
|
3271 |
|
3272 |
|
3273 // --------------------------------------------------------- |
|
3274 // CApSettingsDlg::CanSaveL( ) |
|
3275 // --------------------------------------------------------- |
|
3276 // |
|
3277 CApSettingsDlg::TSaveAction CApSettingsDlg::CanSaveL( TApMember& aDataNeeded ) |
|
3278 { |
|
3279 APSETUILOGGER_ENTERFN( ESettings,"Settings::CanSaveL") |
|
3280 |
|
3281 TSaveAction retval( EApCanSave ); |
|
3282 |
|
3283 // it is used in two cases, less code by doing it here |
|
3284 HBufC *sgd = HBufC::NewLC( KModifiableTextLength ); |
|
3285 TPtr16 ptr( sgd->Des() ); |
|
3286 |
|
3287 switch ( iBearerType ) |
|
3288 { |
|
3289 case EApBearerTypeCSD: |
|
3290 case EApBearerTypeHSCSD: |
|
3291 { |
|
3292 iApItem->ReadTextL( EApIspDefaultTelNumber, ptr ); |
|
3293 if ( *sgd == KEmptyText ) |
|
3294 { |
|
3295 retval = EApMustDelete; |
|
3296 if ( !( *iEventStore & KApUiEventExitRequested ) ) |
|
3297 { |
|
3298 if ( ! AskQueryL( R_APUI_AP_ACCESS_NUMBER_NOT ) ) |
|
3299 { |
|
3300 retval = EApShallGoBack; |
|
3301 aDataNeeded = EApIspDefaultTelNumber; |
|
3302 } |
|
3303 } |
|
3304 } |
|
3305 break; |
|
3306 } |
|
3307 case EApBearerTypeGPRS: |
|
3308 { |
|
3309 // nothing to do... |
|
3310 break; |
|
3311 } |
|
3312 case EApBearerTypeWLAN: |
|
3313 { |
|
3314 if ( IsWlanSupported() ) |
|
3315 { |
|
3316 iApItem->ReadTextL( EApWlanNetworkName, ptr ); |
|
3317 if ( *sgd == KEmptyText ) |
|
3318 { |
|
3319 retval = EApShallGoBack; |
|
3320 aDataNeeded = EApWlanNetworkName; |
|
3321 if ( !( *iEventStore & KApUiEventExitRequested ) ) |
|
3322 { |
|
3323 if ( AskQueryL( R_APUI_AP_WLAN_NAME_NOT_DEFINED ) ) |
|
3324 { |
|
3325 retval = EApMustDelete; |
|
3326 } |
|
3327 } |
|
3328 } |
|
3329 if ( (retval != EApShallGoBack) && (retval != EApMustDelete) |
|
3330 && IsNetMaskAndGatewayVisibleL() ) |
|
3331 { // now check compulsory fields |
|
3332 iApItem->ReadTextL( EApWlanIpNetMask, ptr ); |
|
3333 if ( ( ptr.Compare( KDynIpAddress ) == 0 ) |
|
3334 || ( ptr.Compare( KEmptyText ) == 0 ) ) |
|
3335 { |
|
3336 retval = EApShallGoBack; |
|
3337 aDataNeeded = EApWlanIpNetMask; |
|
3338 if ( AskQueryL( |
|
3339 R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) ) |
|
3340 { |
|
3341 retval = EApMustDelete; |
|
3342 } |
|
3343 } |
|
3344 else |
|
3345 { |
|
3346 iApItem->ReadTextL( EApIspIPGateway, ptr ); |
|
3347 if ( ( sgd->Compare( KDynIpAddress ) == 0 ) |
|
3348 || ( sgd->Compare( KEmptyText ) == 0 ) ) |
|
3349 { |
|
3350 retval = EApShallGoBack; |
|
3351 aDataNeeded = EApIspIPGateway; |
|
3352 if ( AskQueryL( |
|
3353 R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) |
|
3354 ) |
|
3355 { |
|
3356 retval = EApMustDelete; |
|
3357 } |
|
3358 } |
|
3359 } |
|
3360 } |
|
3361 if ( (retval != EApShallGoBack) && (retval != EApMustDelete) |
|
3362 && (!HasSecuritySettingsFilledL()) ) |
|
3363 { |
|
3364 retval = EApShallGoBack; |
|
3365 aDataNeeded = EApWlanSecuritySettings; |
|
3366 if ( !( *iEventStore & KApUiEventExitRequested ) ) |
|
3367 { |
|
3368 if ( AskQueryL( R_APUI_AP_WLAN_SEC_SETT_EMPTY ) ) |
|
3369 { |
|
3370 retval = EApMustDelete; |
|
3371 } |
|
3372 } |
|
3373 } |
|
3374 } |
|
3375 else |
|
3376 { |
|
3377 User::Leave( KErrNotSupported ); |
|
3378 } |
|
3379 break; |
|
3380 } |
|
3381 default: |
|
3382 { // in release, leave, in debug, PANIC |
|
3383 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
3384 User::Leave( KErrInvalidBearerType ); |
|
3385 break; |
|
3386 } |
|
3387 } |
|
3388 CleanupStack::PopAndDestroy( sgd ); // sgd |
|
3389 |
|
3390 if ( ( retval == EApShallGoBack ) && |
|
3391 ( *iEventStore & KApUiEventExitRequested ) ) |
|
3392 { |
|
3393 retval = EApNoAction; |
|
3394 } |
|
3395 |
|
3396 APSETUILOGGER_LEAVEFN( ESettings,"Settings::CanSaveL") |
|
3397 return retval; |
|
3398 } |
|
3399 |
|
3400 |
|
3401 |
|
3402 |
|
3403 |
|
3404 |
|
3405 //---------------------------------------------------------- |
|
3406 // CApSettingsDlg::ShowPopupIpAddrSettingPageL |
|
3407 //---------------------------------------------------------- |
|
3408 // |
|
3409 void CApSettingsDlg::ShowPopupIpAddrSettingPageL( TApMember aData ) |
|
3410 { |
|
3411 APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupIpAddrSettingPageL") |
|
3412 |
|
3413 HBufC* aBuf = HBufC::NewLC( KModifiableTextLength ); |
|
3414 TPtr16 ptr( aBuf->Des() ); |
|
3415 |
|
3416 iApItem->ReadTextL( aData, ptr ); |
|
3417 |
|
3418 TBuf<KModifiableTextLength> textToChange; |
|
3419 |
|
3420 textToChange.Append( ptr ); |
|
3421 |
|
3422 TInt page_resid( 0 ); |
|
3423 TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); |
|
3424 GetTextResId( aData, page_resid, TextSettingPageFlags ); |
|
3425 |
|
3426 TInetAddr AddrToChange; |
|
3427 AddrToChange.Input( textToChange ); |
|
3428 CAknIpFieldSettingPage* dlg = |
|
3429 new( ELeave )CAknIpFieldSettingPage( page_resid, AddrToChange ); |
|
3430 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) |
|
3431 { |
|
3432 // first need to check phone number validity, if not, |
|
3433 // display error msg, |
|
3434 AddrToChange.Output( textToChange ); |
|
3435 iApItem->WriteTextL( aData, textToChange ); |
|
3436 } |
|
3437 CleanupStack::PopAndDestroy(); // aBuf |
|
3438 |
|
3439 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupIpAddrSettingPageL") |
|
3440 } |
|
3441 |
|
3442 |
|
3443 |
|
3444 |
|
3445 |
|
3446 |
|
3447 //---------------------------------------------------------- |
|
3448 // CApSettingsDlg::ShowPopupPhoneNumSettingPageL |
|
3449 //---------------------------------------------------------- |
|
3450 // |
|
3451 void CApSettingsDlg::ShowPopupPhoneNumSettingPageL( TApMember aData ) |
|
3452 { |
|
3453 APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupPhoneNumSettingPageL") |
|
3454 |
|
3455 HBufC* aBuf = HBufC::NewLC( KModifiableTextLength ); |
|
3456 TPtr16 ptr( aBuf->Des() ); |
|
3457 |
|
3458 if ( aData == EApIspIfCallbackInfo ) |
|
3459 { // 8 bit text |
|
3460 HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); |
|
3461 TPtr8 ptr8( tmpValue8->Des() ); |
|
3462 iApItem->ReadTextL( aData, ptr8 ); |
|
3463 ptr.Copy( ptr8 ); |
|
3464 CleanupStack::PopAndDestroy(); // tmpvalue8 |
|
3465 } |
|
3466 else |
|
3467 { |
|
3468 iApItem->ReadTextL( aData, ptr ); |
|
3469 } |
|
3470 |
|
3471 TBuf<KModifiableTextLength> textToChange; |
|
3472 |
|
3473 textToChange.Append( ptr ); |
|
3474 |
|
3475 TInt page_resid( 0 ); |
|
3476 TInt TextSettingPageFlags( EAknSettingPageNoOrdinalDisplayed ); |
|
3477 GetTextResId( aData, page_resid, TextSettingPageFlags ); |
|
3478 TBool mustgoon( ETrue ); |
|
3479 do |
|
3480 { |
|
3481 CAknSettingPage* dlg = |
|
3482 new( ELeave )CAknTextSettingPage( page_resid, |
|
3483 textToChange, |
|
3484 TextSettingPageFlags ); |
|
3485 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) |
|
3486 { |
|
3487 // first need to check phone number validity, |
|
3488 // if not, dispaly error msg, |
|
3489 // bearing in mind that if empty is not allowed, |
|
3490 // we can not got empty text from editor, so IF it is not a valid |
|
3491 // phone number, but it is empty, thna it is allowed and |
|
3492 // it is the user's wish, so go on as valid... |
|
3493 // MNAN-6XBFNB: Digits that are not western should also be accepted |
|
3494 // Convert digits to western and check the phone number like this. |
|
3495 TBuf<KModifiableTextLength> temp; |
|
3496 temp = textToChange; |
|
3497 AknTextUtils::ConvertDigitsTo( temp, EDigitTypeWestern ); |
|
3498 |
|
3499 if ( CommonPhoneParser::IsValidPhoneNumber |
|
3500 ( temp, CommonPhoneParser::EContactCardNumber ) |
|
3501 || ( temp.Compare( KEmpty ) == 0) ) |
|
3502 { |
|
3503 if ( aData == EApIspIfCallbackInfo ) |
|
3504 { // 8 bit text |
|
3505 HBufC8* tmpValue8 = HBufC8::NewLC( KModifiableTextLength ); |
|
3506 TPtr8 ptr8( tmpValue8->Des() ); |
|
3507 iApItem->ReadTextL( aData, ptr8 ); |
|
3508 ptr8.Copy( textToChange ); |
|
3509 iApItem->WriteTextL( aData, ptr8 ); |
|
3510 CleanupStack::PopAndDestroy(); // tmpvalue8 |
|
3511 } |
|
3512 else |
|
3513 { |
|
3514 iApItem->WriteTextL( aData, textToChange ); |
|
3515 } |
|
3516 mustgoon = EFalse; |
|
3517 } |
|
3518 else |
|
3519 { // give invalid number message |
|
3520 ShowNoteL( R_APUI_VIEW_INVALID_NUMBER ); |
|
3521 } |
|
3522 } |
|
3523 else |
|
3524 { |
|
3525 mustgoon = EFalse; |
|
3526 } |
|
3527 } |
|
3528 while( mustgoon ); |
|
3529 CleanupStack::PopAndDestroy(); // aBuf |
|
3530 |
|
3531 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupPhoneNumSettingPageL") |
|
3532 } |
|
3533 |
|
3534 |
|
3535 |
|
3536 |
|
3537 //---------------------------------------------------------- |
|
3538 // CApSettingsDlg::ShowPopupPasswordPageL |
|
3539 //---------------------------------------------------------- |
|
3540 // |
|
3541 void CApSettingsDlg::ShowPopupPasswordPageL( TApMember aData ) |
|
3542 { |
|
3543 APSETUILOGGER_ENTERFN( ESettings,"Settings::ShowPopupPasswordPageL") |
|
3544 |
|
3545 // must be prepared for the worst case... |
|
3546 TBuf<KMaxLoginPasswordLength> newpass; |
|
3547 |
|
3548 TUint32 txtLength = iApItem->ReadTextLengthL( aData ); |
|
3549 // allocates as much as needed... |
|
3550 HBufC* oldpass = HBufC::NewLC( txtLength ); |
|
3551 TPtr16 ptr( oldpass->Des() ); |
|
3552 iApItem->ReadTextL( aData, ptr ); |
|
3553 |
|
3554 CAknAlphaPasswordSettingPage* dlg = |
|
3555 new( ELeave )CAknAlphaPasswordSettingPage( |
|
3556 R_TEXT_SETTING_PAGE_LOGIN_PASSWD, |
|
3557 newpass, ptr ); |
|
3558 CleanupStack::PushL(dlg); |
|
3559 // As password is asked only once... |
|
3560 dlg->SetMaxPasswordLength( KMaxLoginPasswordLength ); |
|
3561 CleanupStack::Pop(); |
|
3562 if ( dlg->ExecuteLD(CAknSettingPage::EUpdateWhenChanged) ) |
|
3563 { |
|
3564 iApItem->WriteTextL( aData, newpass ); |
|
3565 } |
|
3566 CleanupStack::PopAndDestroy(); // oldpass |
|
3567 |
|
3568 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ShowPopupPasswordPageL") |
|
3569 } |
|
3570 |
|
3571 |
|
3572 |
|
3573 //---------------------------------------------------------- |
|
3574 // CApSettingsDlg::GetBoolDataValue |
|
3575 //---------------------------------------------------------- |
|
3576 // |
|
3577 void CApSettingsDlg::GetBoolDataValue( TApMember aData, TBool aInvert, |
|
3578 TInt& aCurrvalue) |
|
3579 { |
|
3580 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetBoolDataValue") |
|
3581 |
|
3582 iApItem->ReadBool( aData, aCurrvalue); |
|
3583 // just to be on the sure side... |
|
3584 aCurrvalue = Min( KBoolMaxNumber, aCurrvalue); |
|
3585 if ( aInvert) |
|
3586 { |
|
3587 aCurrvalue = !aCurrvalue; |
|
3588 } |
|
3589 |
|
3590 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetBoolDataValue") |
|
3591 } |
|
3592 |
|
3593 |
|
3594 //---------------------------------------------------------- |
|
3595 // CApSettingsDlg::DoBearerChangeL |
|
3596 //---------------------------------------------------------- |
|
3597 // |
|
3598 void CApSettingsDlg::DoBearerChangeL( TInt aCurrvalue) |
|
3599 { |
|
3600 APSETUILOGGER_ENTERFN( ESettings,"Settings::DoBearerChangeL") |
|
3601 |
|
3602 TApBearerType newbearer = BearerItemPos2BearerTypeL( aCurrvalue ); |
|
3603 HandleBearerChangeL( newbearer ); |
|
3604 |
|
3605 APSETUILOGGER_LEAVEFN( ESettings,"Settings::DoBearerChangeL") |
|
3606 } |
|
3607 |
|
3608 |
|
3609 |
|
3610 //---------------------------------------------------------- |
|
3611 // CApSettingsDlg::HandleBearerChangeL |
|
3612 //---------------------------------------------------------- |
|
3613 // |
|
3614 void CApSettingsDlg::HandleBearerChangeL( TApBearerType aBearer) |
|
3615 { |
|
3616 APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleBearerChangeL") |
|
3617 |
|
3618 if ( iBearerItemArray->At( BearerToArrayIndexL( aBearer)) == NULL) |
|
3619 { |
|
3620 CApAccessPointItem* ap = CApAccessPointItem::NewLC(); |
|
3621 ap->CopyFromL( *iApItem); |
|
3622 ap->WriteUint( EApWapAccessPointID, iApItem->WapUid()); |
|
3623 iBearerItemArray->At( BearerToArrayIndexL( aBearer)) = ap; |
|
3624 iApItem = ap; |
|
3625 CleanupStack::Pop(); // ap |
|
3626 } |
|
3627 else |
|
3628 { |
|
3629 iApItem = iBearerItemArray->At( BearerToArrayIndexL( aBearer)); |
|
3630 } |
|
3631 iApItem->SetBearerTypeL( aBearer ); |
|
3632 SetBearerTypeL( aBearer ); |
|
3633 |
|
3634 APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleBearerChangeL") |
|
3635 } |
|
3636 |
|
3637 |
|
3638 //---------------------------------------------------------- |
|
3639 // CApSettingsDlg::BearerToArrayIndexL |
|
3640 //---------------------------------------------------------- |
|
3641 // |
|
3642 TInt32 CApSettingsDlg::BearerToArrayIndexL( TApBearerType aBearer) |
|
3643 { |
|
3644 APSETUILOGGER_ENTERFN( ESettings,"Settings::BearerToArrayIndexL") |
|
3645 |
|
3646 TInt32 retval( KBearerArrayGPRS ); |
|
3647 switch( aBearer ) |
|
3648 { |
|
3649 case EApBearerTypeCSD: |
|
3650 { |
|
3651 retval = KBearerArrayCSD; |
|
3652 break; |
|
3653 } |
|
3654 case EApBearerTypeGPRS: |
|
3655 { |
|
3656 retval = KBearerArrayGPRS; |
|
3657 break; |
|
3658 } |
|
3659 case EApBearerTypeHSCSD: |
|
3660 { |
|
3661 retval = KBearerArrayHSCSD; |
|
3662 break; |
|
3663 } |
|
3664 case EApBearerTypeWLAN: |
|
3665 { |
|
3666 if ( IsWlanSupported() ) |
|
3667 { |
|
3668 retval = KBearerArrayWLAN; |
|
3669 } |
|
3670 else |
|
3671 { |
|
3672 User::Leave( KErrNotSupported ); |
|
3673 } |
|
3674 break; |
|
3675 } |
|
3676 default: |
|
3677 { |
|
3678 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
3679 User::Leave( KErrInvalidBearerType ); |
|
3680 break; |
|
3681 } |
|
3682 } |
|
3683 |
|
3684 APSETUILOGGER_LEAVEFN( ESettings,"Settings::BearerToArrayIndexL") |
|
3685 return retval; |
|
3686 } |
|
3687 |
|
3688 /* |
|
3689 //---------------------------------------------------------- |
|
3690 // CApSettingsDlg::ArrayIndexToBearer |
|
3691 //---------------------------------------------------------- |
|
3692 // |
|
3693 TApBearerType CApSettingsDlg::ArrayIndexToBearer( TInt32 aIndex) |
|
3694 { |
|
3695 APSETUILOGGER_ENTERFN( ESettings,"Settings::ArrayIndexToBearer") |
|
3696 |
|
3697 TApBearerType retval( EApBearerTypeGPRS ); |
|
3698 switch( aIndex ) |
|
3699 { |
|
3700 case KBearerArrayCSD: |
|
3701 { |
|
3702 retval = EApBearerTypeCSD; |
|
3703 break; |
|
3704 } |
|
3705 case KBearerArrayGPRS: |
|
3706 { |
|
3707 retval = EApBearerTypeGPRS; |
|
3708 break; |
|
3709 } |
|
3710 case KBearerArrayHSCSD: |
|
3711 { |
|
3712 retval = EApBearerTypeHSCSD; |
|
3713 break; |
|
3714 } |
|
3715 case KBearerArrayWLAN: |
|
3716 { |
|
3717 if ( IsWlanSupported() ) |
|
3718 { |
|
3719 retval = EApBearerTypeWLAN; |
|
3720 } |
|
3721 else |
|
3722 { |
|
3723 User::Leave( KErrNotSupported ); |
|
3724 } |
|
3725 break; |
|
3726 } |
|
3727 default: |
|
3728 { |
|
3729 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
3730 break; |
|
3731 } |
|
3732 } |
|
3733 |
|
3734 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ArrayIndexToBearer") |
|
3735 return retval; |
|
3736 } |
|
3737 |
|
3738 */ |
|
3739 |
|
3740 |
|
3741 //---------------------------------------------------------- |
|
3742 // CApSettingsDlg::FillUpBearerSpeedValuesL |
|
3743 //---------------------------------------------------------- |
|
3744 // |
|
3745 void CApSettingsDlg::FillUpBearerSpeedValuesL( CDesCArrayFlat& aItems, |
|
3746 TInt& aCurrvalue ) |
|
3747 { |
|
3748 APSETUILOGGER_ENTERFN( ESettings,"Settings::FillUpBearerSpeedValuesL") |
|
3749 |
|
3750 TUint32 tval( 0 ); |
|
3751 TUint32 bval( 0 ); |
|
3752 |
|
3753 iApItem->ReadUint( EApIspBearerSpeed, tval ); |
|
3754 iApItem->ReadUint( EApIspBearerCallTypeIsdn, bval ); |
|
3755 TApBearerType btype = iApItem->BearerTypeL(); |
|
3756 const TInt* actResSpeeds = NULL; |
|
3757 const TInt* actSpeeds = NULL; |
|
3758 |
|
3759 TBool isWcdma = |
|
3760 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); |
|
3761 |
|
3762 switch ( bval ) |
|
3763 { |
|
3764 case ECallTypeAnalogue: |
|
3765 { // CSD/HSCSD, Analogue |
|
3766 if ( btype == EApBearerTypeHSCSD ) |
|
3767 { |
|
3768 actResSpeeds = KResHcsdAnalogue; |
|
3769 actSpeeds = KHcsdAnalogue; |
|
3770 } |
|
3771 else |
|
3772 { |
|
3773 actResSpeeds = KResCsdAnalogue; |
|
3774 actSpeeds = KCsdAnalogue; |
|
3775 if ( isWcdma ) |
|
3776 { |
|
3777 actResSpeeds = KResCsdAnalogueWcdma; |
|
3778 actSpeeds = KCsdAnalogueWcdma; |
|
3779 } |
|
3780 } |
|
3781 break; |
|
3782 } |
|
3783 case ECallTypeISDNv110: |
|
3784 { // CSD/HSCSD, ISDN v110: |
|
3785 if ( btype == EApBearerTypeHSCSD ) |
|
3786 { |
|
3787 actResSpeeds = KResHcsdIsdn110; |
|
3788 actSpeeds = KHcsdIsdn110; |
|
3789 } |
|
3790 else |
|
3791 { |
|
3792 actResSpeeds = KResCsdIsdn110; |
|
3793 actSpeeds = KCsdIsdn110; |
|
3794 if ( isWcdma ) |
|
3795 { |
|
3796 actResSpeeds = KResCsdIsdn110Wcdma; |
|
3797 actSpeeds = KCsdIsdn110Wcdma; |
|
3798 } |
|
3799 } |
|
3800 break; |
|
3801 } |
|
3802 case ECallTypeISDNv120: |
|
3803 { |
|
3804 if ( btype == EApBearerTypeHSCSD ) |
|
3805 { |
|
3806 actResSpeeds = KResHcsdIsdn120; |
|
3807 actSpeeds = KHcsdIsdn120; |
|
3808 } |
|
3809 else |
|
3810 { |
|
3811 actResSpeeds = KResCsdIsdn120; |
|
3812 actSpeeds = KCsdIsdn120; |
|
3813 if ( isWcdma ) |
|
3814 { |
|
3815 actResSpeeds = KResCsdIsdn120Wcdma; |
|
3816 actSpeeds = KCsdIsdn120Wcdma; |
|
3817 } |
|
3818 } |
|
3819 break; |
|
3820 } |
|
3821 default: |
|
3822 { |
|
3823 break; |
|
3824 } |
|
3825 } |
|
3826 |
|
3827 if ( actResSpeeds ) |
|
3828 { |
|
3829 while ( *actResSpeeds != KEndOfArray ) |
|
3830 { |
|
3831 aItems.AppendL( *iEikonEnv->AllocReadResourceLC( *actResSpeeds ) ); |
|
3832 CleanupStack::PopAndDestroy(); |
|
3833 ++actResSpeeds; |
|
3834 } |
|
3835 } |
|
3836 |
|
3837 if( actSpeeds ) |
|
3838 { |
|
3839 aCurrvalue = 0; |
|
3840 TInt nextSpeed = *( actSpeeds + aCurrvalue + 1) ; |
|
3841 while ( ( nextSpeed != KEndOfArray ) |
|
3842 && ( *( actSpeeds + aCurrvalue) < ( TInt )tval ) |
|
3843 && ( nextSpeed <= ( TInt )tval ) ) |
|
3844 { |
|
3845 ++aCurrvalue; |
|
3846 nextSpeed = *( actSpeeds + aCurrvalue + 1) ; |
|
3847 } |
|
3848 } |
|
3849 |
|
3850 APSETUILOGGER_LEAVEFN( ESettings,"Settings::FillUpBearerSpeedValuesL") |
|
3851 } |
|
3852 |
|
3853 |
|
3854 |
|
3855 //---------------------------------------------------------- |
|
3856 // CApSettingsDlg::SaveDataL |
|
3857 //---------------------------------------------------------- |
|
3858 // |
|
3859 TBool CApSettingsDlg::SaveDataL( ) |
|
3860 { |
|
3861 APSETUILOGGER_ENTERFN( ESettings,"Settings::SaveDataL") |
|
3862 |
|
3863 TApMember aDataNeeded; |
|
3864 TSaveAction action(EApCanSave); |
|
3865 TBool retval( ETrue ); |
|
3866 TInt err (KErrNone ); |
|
3867 |
|
3868 // first handle ALL db stuff because Symbian DB does handles |
|
3869 // consequtive transactions wrongly... |
|
3870 TTransactionResult ownTransaction = |
|
3871 iDataModel->StartTransactionLC( |
|
3872 /*aWrite*/EFalse, |
|
3873 /*aShowNote*/ETrue, |
|
3874 /*aRetry*/ETrue ); |
|
3875 if ( ownTransaction != EFailedWithLocked ) |
|
3876 { |
|
3877 action = CanSaveL(aDataNeeded); |
|
3878 switch ( action ) |
|
3879 { |
|
3880 case EApCanSave: |
|
3881 #ifdef __WINS__ |
|
3882 case EApMustDelete: |
|
3883 #endif // __WINS__ |
|
3884 { // save data |
|
3885 if ( ( *iOldApItem != *iApItem ) || ( *iUid == KApNoneUID ) |
|
3886 || iDataModel->iWepSecSettings |
|
3887 || iDataModel->iWpaSecSettings ) |
|
3888 { // save if different or NEW BLANK |
|
3889 *iEventStore |= KApUiEventEdited; |
|
3890 if ( *iUid == KApNoneUID ) |
|
3891 { |
|
3892 HBufC* buf = HBufC::NewLC( KApMaxConnNameLength ); |
|
3893 // now check if name is unique, if it is, |
|
3894 // save and commit, if it is not, show note |
|
3895 // and no save at all, Rollback! |
|
3896 TPtr16 ptr( buf->Des() ); |
|
3897 iApItem->ReadTextL( EApWapAccessPointName, ptr ); |
|
3898 TBool b(EFalse); |
|
3899 TRAP( err, b = |
|
3900 iDataModel->ApUtils()->IsValidNameL( ptr ) ); |
|
3901 CleanupStack::PopAndDestroy( buf ); |
|
3902 if ( b ) |
|
3903 { |
|
3904 TRAP( err, |
|
3905 iDataModel->CreateFromDataL( *iApItem ) ); |
|
3906 if ( err == KErrNone ) |
|
3907 { |
|
3908 iApItem->ReadUint( EApWapAccessPointID, |
|
3909 *iUid ); |
|
3910 *iEventStore |= KApUiEventCreatedBlank; |
|
3911 } |
|
3912 } |
|
3913 else |
|
3914 { |
|
3915 err = KErrAlreadyExists; |
|
3916 // no DB call after this point, as transaction must be rolled back, |
|
3917 // but we can do it only at the end |
|
3918 if ( ownTransaction == EOwnTransaction ) |
|
3919 { |
|
3920 CleanupStack::PopAndDestroy(); //Rollback |
|
3921 // set as if no need to commit... |
|
3922 ownTransaction = EUsingAlreadyStarted; |
|
3923 } |
|
3924 } |
|
3925 } |
|
3926 else |
|
3927 { |
|
3928 // If the name is not unique, |
|
3929 // it will leave with KErrAlreadyExists |
|
3930 TRAP( err, |
|
3931 iDataModel->UpdateAccessPointDataL( *iApItem ) ); |
|
3932 } |
|
3933 } |
|
3934 break; |
|
3935 } |
|
3936 #ifndef __WINS__ |
|
3937 case EApMustDelete: |
|
3938 { |
|
3939 if ( *iUid != KApNoneUID ) |
|
3940 { |
|
3941 TUint32 WapUid( 0 ); |
|
3942 iApItem->ReadUint( EApWapAccessPointID, WapUid ); |
|
3943 iDataModel->RemoveApL( WapUid ); |
|
3944 } |
|
3945 break; |
|
3946 } |
|
3947 #endif // __WINS__ |
|
3948 case EApShallGoBack: |
|
3949 { |
|
3950 switch ( aDataNeeded ) |
|
3951 { |
|
3952 case EApIspDefaultTelNumber: |
|
3953 { |
|
3954 SelectItem( KListIndexCSDAccessNumber ); |
|
3955 retval = EFalse; |
|
3956 break; |
|
3957 } |
|
3958 case EApWlanNetworkName: |
|
3959 { |
|
3960 if ( IsWlanSupported() ) |
|
3961 { |
|
3962 SelectItem( KListIndexWLANNetworkName ); |
|
3963 retval = EFalse; |
|
3964 } |
|
3965 else |
|
3966 { |
|
3967 User::Leave( KErrNotSupported ); |
|
3968 } |
|
3969 break; |
|
3970 } |
|
3971 case EApWlanIpNetMask: |
|
3972 case EApIspIPNetMask: |
|
3973 { |
|
3974 if ( IsWlanSupported() ) |
|
3975 { |
|
3976 SelectItem( KListIndexWLANSubnetMask ); |
|
3977 retval = EFalse; |
|
3978 } |
|
3979 else |
|
3980 { |
|
3981 User::Leave( KErrNotSupported ); |
|
3982 } |
|
3983 break; |
|
3984 } |
|
3985 case EApIspIPGateway: |
|
3986 case EApWlanIpGateway: |
|
3987 { |
|
3988 if ( IsWlanSupported() ) |
|
3989 { |
|
3990 SelectItem( KListIndexWLANDefaultGateway ); |
|
3991 retval = EFalse; |
|
3992 } |
|
3993 else |
|
3994 { |
|
3995 User::Leave( KErrNotSupported ); |
|
3996 } |
|
3997 break; |
|
3998 } |
|
3999 case EApWlanSecuritySettings: |
|
4000 { |
|
4001 if ( IsWlanSupported() ) |
|
4002 { |
|
4003 SelectItem( KListIndexWLANSecuritySettings ); |
|
4004 retval = EFalse; |
|
4005 ChangeSettingsL( EFalse ); |
|
4006 } |
|
4007 else |
|
4008 { |
|
4009 User::Leave( KErrNotSupported ); |
|
4010 } |
|
4011 break; |
|
4012 } |
|
4013 default: |
|
4014 {// otherwise, nothing to do... |
|
4015 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4016 break; |
|
4017 } |
|
4018 } |
|
4019 break; |
|
4020 } |
|
4021 case EApNoAction: |
|
4022 { // can not save, do not go back: Exit, do nothing but ignore... |
|
4023 break; |
|
4024 } |
|
4025 default: |
|
4026 { |
|
4027 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4028 break; |
|
4029 } |
|
4030 } |
|
4031 |
|
4032 if ( ownTransaction == EOwnTransaction ) |
|
4033 { |
|
4034 err = iDataModel->Database()->Database()->CommitTransaction(); |
|
4035 User::LeaveIfError( err ); |
|
4036 CleanupStack::Pop(); // RollbackTransaction |
|
4037 } |
|
4038 } |
|
4039 else |
|
4040 { |
|
4041 User::Leave( KErrLocked ); |
|
4042 } |
|
4043 // end transaction stuff |
|
4044 // and handle possible other stuff like |
|
4045 // displaying notifications, redirecting the user, etc... |
|
4046 |
|
4047 if ( err == KErrAlreadyExists ) |
|
4048 { |
|
4049 // Check if exit and if it is, Exit, |
|
4050 // if it is not, then show note |
|
4051 // and move user back to editor... |
|
4052 if ( !( *iEventStore & KApUiEventExitRequested ) ) |
|
4053 { |
|
4054 HBufC* buf = HBufC::NewLC( KApMaxConnNameLength ); |
|
4055 TPtr16 ptr( buf->Des() ); |
|
4056 iApItem->ReadTextL( EApWapAccessPointName, ptr ); |
|
4057 ShowNoteL( R_APUI_IAP_NAME_ALREADY_EXISTS, buf ); |
|
4058 CleanupStack::PopAndDestroy( buf ); // buf |
|
4059 SelectItem( KListIndexConnectionName ); |
|
4060 retval = EFalse; |
|
4061 ChangeSettingsL( EFalse ); |
|
4062 } |
|
4063 } |
|
4064 else |
|
4065 { |
|
4066 if ( err == KErrInvalidName ) |
|
4067 { |
|
4068 ShowNoteL( R_APUI_VIEW_INVALID_CONN_NAME ); |
|
4069 SelectItem( KListIndexConnectionName ); |
|
4070 retval = EFalse; |
|
4071 } |
|
4072 else |
|
4073 { |
|
4074 if ( !( *iEventStore & KApUiEventExitRequested ) ) |
|
4075 { |
|
4076 User::LeaveIfError( err ); |
|
4077 } |
|
4078 iOldApItem->CopyFromL( *iApItem ); |
|
4079 } |
|
4080 } |
|
4081 |
|
4082 APSETUILOGGER_LEAVEFN( ESettings,"Settings::SaveDataL") |
|
4083 return retval; |
|
4084 } |
|
4085 |
|
4086 |
|
4087 |
|
4088 //---------------------------------------------------------- |
|
4089 // CApSettingsDlg::HandleListStructureChangeL |
|
4090 //---------------------------------------------------------- |
|
4091 // |
|
4092 void CApSettingsDlg::HandleListStructureChangeL() |
|
4093 { |
|
4094 APSETUILOGGER_ENTERFN( ESettings,"Settings::HandleListStructureChangeL") |
|
4095 |
|
4096 TUint32 l = iApItem->ReadTextLengthL( EApWapGatewayAddress ); |
|
4097 HBufC* buf = HBufC::NewLC( l ); |
|
4098 TPtr16 ptr( buf->Des() ); |
|
4099 iApItem->ReadTextL( EApWapGatewayAddress, ptr ); |
|
4100 |
|
4101 if ( ( iBearerType == EApBearerTypeCSD ) |
|
4102 || ( iBearerType == EApBearerTypeHSCSD ) ) |
|
4103 { |
|
4104 GetCSDSettingArrays( iVariant ); |
|
4105 } |
|
4106 else |
|
4107 { |
|
4108 if ( iBearerType == EApBearerTypeGPRS ) |
|
4109 { |
|
4110 GetGPRSSettingArrays( iVariant ); |
|
4111 } |
|
4112 else |
|
4113 { |
|
4114 if ( IsWlanSupported() ) |
|
4115 { |
|
4116 if ( iBearerType == EApBearerTypeWLAN ) |
|
4117 { |
|
4118 GetWLANSettingArraysL( iVariant ); |
|
4119 } |
|
4120 else |
|
4121 { |
|
4122 User::Leave( KErrInvalidBearer ); |
|
4123 } |
|
4124 } |
|
4125 else |
|
4126 { |
|
4127 User::Leave( KErrInvalidBearer ); |
|
4128 } |
|
4129 } |
|
4130 } |
|
4131 CleanupStack::PopAndDestroy( buf ); |
|
4132 |
|
4133 APSETUILOGGER_LEAVEFN( ESettings,"Settings::HandleListStructureChangeL") |
|
4134 } |
|
4135 |
|
4136 |
|
4137 |
|
4138 //---------------------------------------------------------- |
|
4139 // CApSettingsDlg::LimitSpeed |
|
4140 //---------------------------------------------------------- |
|
4141 // |
|
4142 void CApSettingsDlg::LimitSpeed() |
|
4143 { |
|
4144 APSETUILOGGER_ENTERFN( ESettings,"Settings::LimitSpeed") |
|
4145 |
|
4146 // now 'limit' the speeds |
|
4147 TUint32 speed( 0 ); |
|
4148 iApItem->ReadUint( EApIspBearerSpeed, speed ); |
|
4149 TUint32 calltype( EFalse ); |
|
4150 iApItem->ReadUint( EApIspBearerCallTypeIsdn, calltype ); |
|
4151 const TInt* actSpeeds = NULL; |
|
4152 TBool isWcdma = |
|
4153 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ) ; |
|
4154 switch ( iBearerType ) |
|
4155 { |
|
4156 case EApBearerTypeCSD: |
|
4157 { |
|
4158 switch ( calltype ) |
|
4159 { |
|
4160 case ECallTypeISDNv110: |
|
4161 { |
|
4162 actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; |
|
4163 break; |
|
4164 } |
|
4165 case ECallTypeISDNv120: |
|
4166 { |
|
4167 actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; |
|
4168 break; |
|
4169 } |
|
4170 case ECallTypeAnalogue: |
|
4171 default: |
|
4172 { |
|
4173 actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; |
|
4174 } |
|
4175 } |
|
4176 break; |
|
4177 } |
|
4178 case EApBearerTypeHSCSD: |
|
4179 { |
|
4180 switch ( calltype ) |
|
4181 { |
|
4182 case ECallTypeISDNv110: |
|
4183 { |
|
4184 actSpeeds = KHcsdIsdn110; |
|
4185 break; |
|
4186 } |
|
4187 case ECallTypeISDNv120: |
|
4188 { |
|
4189 actSpeeds = KHcsdIsdn120; |
|
4190 break; |
|
4191 } |
|
4192 case ECallTypeAnalogue: |
|
4193 default: |
|
4194 { |
|
4195 actSpeeds = KHcsdAnalogue; |
|
4196 } |
|
4197 } |
|
4198 break; |
|
4199 } |
|
4200 default: |
|
4201 { |
|
4202 break; |
|
4203 } |
|
4204 } |
|
4205 |
|
4206 if( actSpeeds ) |
|
4207 { |
|
4208 TInt tempSpeed = *actSpeeds; |
|
4209 TInt nextSpeed = *( actSpeeds + 1 ); |
|
4210 while ( ( nextSpeed != KEndOfArray ) |
|
4211 && ( tempSpeed < ( TInt )speed ) |
|
4212 && ( nextSpeed <= ( TInt )speed ) ) |
|
4213 { |
|
4214 tempSpeed = *( ++actSpeeds ); |
|
4215 nextSpeed = *( actSpeeds + 1 ); |
|
4216 } |
|
4217 speed = tempSpeed ; |
|
4218 } |
|
4219 |
|
4220 |
|
4221 iApItem->WriteUint( EApIspBearerSpeed, speed ); |
|
4222 |
|
4223 APSETUILOGGER_LEAVEFN( ESettings,"Settings::LimitSpeed") |
|
4224 } |
|
4225 |
|
4226 |
|
4227 //---------------------------------------------------------- |
|
4228 // CApSettingsDlg::SelectItem |
|
4229 //---------------------------------------------------------- |
|
4230 // |
|
4231 void CApSettingsDlg::SelectItem( TInt aItemIndex ) |
|
4232 { |
|
4233 APSETUILOGGER_ENTERFN( ESettings,"Settings::SelectItem") |
|
4234 |
|
4235 iList->ScrollToMakeItemVisible( aItemIndex ); |
|
4236 iList->SetCurrentItemIndexAndDraw( aItemIndex ); |
|
4237 |
|
4238 APSETUILOGGER_LEAVEFN( ESettings,"Settings::SelectItem") |
|
4239 } |
|
4240 |
|
4241 |
|
4242 |
|
4243 |
|
4244 |
|
4245 // Converting EParagraphDelimiters to \ns |
|
4246 // --------------------------------------------------------- |
|
4247 // CApSettingsDlg::ConvertDelimToPerNLC |
|
4248 // --------------------------------------------------------- |
|
4249 // |
|
4250 HBufC* CApSettingsDlg::ConvertDelimToPerNLC( const TDesC& aInText ) |
|
4251 { |
|
4252 APSETUILOGGER_ENTERFN( ESettings,"Settings::ConvertDelimToPerNLC") |
|
4253 |
|
4254 TInt size = aInText.Length(); |
|
4255 HBufC* outText = HBufC::NewLC( size ); |
|
4256 TPtr ptr = outText->Des(); |
|
4257 |
|
4258 for ( TInt ii=0; ii<size; ++ii ) |
|
4259 { |
|
4260 TText ch = aInText[ii]; |
|
4261 if ( ch == CEditableText::ELineBreak || |
|
4262 ch == CEditableText::EParagraphDelimiter ) |
|
4263 { |
|
4264 ch = '\n'; |
|
4265 } |
|
4266 ptr.Append( ch ); |
|
4267 } |
|
4268 |
|
4269 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ConvertDelimToPerNLC") |
|
4270 return outText; |
|
4271 } |
|
4272 |
|
4273 |
|
4274 |
|
4275 // Converting \ns to EParagraphDelimiters |
|
4276 // --------------------------------------------------------- |
|
4277 // CApSettingsDlg::ConvertPerNToDelimLC |
|
4278 // --------------------------------------------------------- |
|
4279 // |
|
4280 |
|
4281 HBufC* CApSettingsDlg::ConvertPerNToDelimLC( const TDesC& aInText ) |
|
4282 { |
|
4283 APSETUILOGGER_ENTERFN( ESettings,"Settings::ConvertPerNToDelimLC") |
|
4284 |
|
4285 TInt size = aInText.Length(); |
|
4286 HBufC* outText = HBufC::NewLC( size ); |
|
4287 TPtr ptr = outText->Des(); |
|
4288 |
|
4289 TText ch; |
|
4290 for (TInt ii=0; ii<size; ii++) |
|
4291 { |
|
4292 ch = TText( aInText[ii] ); |
|
4293 switch (ch) |
|
4294 { |
|
4295 case '\r': |
|
4296 // ignore |
|
4297 ptr.Append(ch); |
|
4298 break; |
|
4299 case '\n': |
|
4300 ptr.Append( CEditableText::EParagraphDelimiter ); |
|
4301 break; |
|
4302 default: |
|
4303 ptr.Append(ch); |
|
4304 break; |
|
4305 } |
|
4306 } |
|
4307 |
|
4308 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ConvertPerNToDelimLC") |
|
4309 return outText; |
|
4310 } |
|
4311 |
|
4312 |
|
4313 //---------------------------------------------------------- |
|
4314 // CApSettingsDlg::DoChangeSettingsL |
|
4315 //---------------------------------------------------------- |
|
4316 // |
|
4317 void CApSettingsDlg::DoChangeSettingsL( TBool aQuick ) |
|
4318 { |
|
4319 APSETUILOGGER_ENTERFN( ESettings,"Settings::DoChangeSettingsL") |
|
4320 |
|
4321 TInt itemnum = ( Max( iList->CurrentItemIndex(), 0 ) ); |
|
4322 TApMember* ptr; |
|
4323 TInt* tptr; |
|
4324 TInt* compulsptr; |
|
4325 switch ( iLevel ) |
|
4326 { |
|
4327 case 0: |
|
4328 { |
|
4329 ptr = iField; |
|
4330 tptr = iTitles; |
|
4331 compulsptr = iCompulsory; |
|
4332 break; |
|
4333 } |
|
4334 case 1: |
|
4335 { |
|
4336 ptr = iFieldAdvanced; |
|
4337 tptr = iTitlesAdvanced; |
|
4338 compulsptr = iCompulsoryAdvanced; |
|
4339 break; |
|
4340 } |
|
4341 case 2: |
|
4342 { |
|
4343 ptr = iFieldL2; |
|
4344 tptr = iTitlesL2; |
|
4345 compulsptr = iCompulsoryL2; |
|
4346 break; |
|
4347 } |
|
4348 default: |
|
4349 { |
|
4350 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4351 return; // just to suppress warnings about ptr's |
|
4352 // beeing used uninitialised |
|
4353 } |
|
4354 } |
|
4355 |
|
4356 |
|
4357 |
|
4358 ptr += itemnum; |
|
4359 tptr += itemnum; |
|
4360 compulsptr += itemnum; |
|
4361 TInt topitem( iList->TopItemIndex() ); |
|
4362 |
|
4363 TApBearerType bearer = iApItem->BearerTypeL(); |
|
4364 if ( bearer == EApBearerTypeGPRS ) |
|
4365 { |
|
4366 TUint32 tint; |
|
4367 iApItem->ReadUint( EApGprsPdpType, tint ); |
|
4368 if ( tint == EIPv6 ) |
|
4369 { |
|
4370 if ( iLevel == 1 ) |
|
4371 { |
|
4372 if ( itemnum ) |
|
4373 { |
|
4374 ptr++; |
|
4375 tptr++; |
|
4376 compulsptr++; |
|
4377 } |
|
4378 } |
|
4379 } |
|
4380 } |
|
4381 else |
|
4382 { // others |
|
4383 if ( bearer == EApBearerTypeWLAN ) |
|
4384 { |
|
4385 // if we are in iL2Ipv4, AND |
|
4386 // EApIspIPNetMask and EApIspIPGateway fields are not added |
|
4387 // skip those items... |
|
4388 if ( !IsNetMaskAndGatewayVisibleL() ) |
|
4389 { |
|
4390 if ( *ptr == EApIspIPNetMask ) |
|
4391 { |
|
4392 ptr++; |
|
4393 tptr++; |
|
4394 compulsptr++; |
|
4395 } |
|
4396 if ( *ptr == EApIspIPGateway ) |
|
4397 { |
|
4398 ptr++; |
|
4399 tptr++; |
|
4400 compulsptr++; |
|
4401 } |
|
4402 } |
|
4403 if ( !IsAdhocChannelVisible() ) |
|
4404 { |
|
4405 if ( ( *ptr == EApWlanChannelId ) |
|
4406 || ( *ptr == EApProxyServerAddress ) ) |
|
4407 { |
|
4408 ptr++; |
|
4409 tptr++; |
|
4410 compulsptr++; |
|
4411 } |
|
4412 } |
|
4413 } |
|
4414 else |
|
4415 { |
|
4416 // CSD |
|
4417 if ( *ptr == EApIspIPAddr ) |
|
4418 { |
|
4419 if ( !iL2Ipv4 ) |
|
4420 { |
|
4421 ptr++; |
|
4422 tptr++; |
|
4423 compulsptr++; |
|
4424 } |
|
4425 } |
|
4426 } |
|
4427 } |
|
4428 |
|
4429 |
|
4430 switch ( *ptr ) |
|
4431 { |
|
4432 case EApIspPromptForLogin: |
|
4433 case EApWapSecurity: |
|
4434 case EApIspIfCallbackEnabled: |
|
4435 case EApIspEnableSWCompression: |
|
4436 case EApGprsHeaderCompression: |
|
4437 case EApIspUseLoginScript: |
|
4438 case EApGprsDisablePlainTextAuth: |
|
4439 case EApIspDisablePlainTextAuth: |
|
4440 case EApWapWspOption: |
|
4441 case EApIspIfCallbackType: |
|
4442 case EApGprsPdpType: |
|
4443 case EApWlanNetworkMode: |
|
4444 case EApWlanScanSSID: |
|
4445 { // type 4 setting item with two available values |
|
4446 TBool changed( ETrue ); |
|
4447 if ( aQuick ) |
|
4448 { |
|
4449 InvertSettingsL( *ptr ); |
|
4450 } |
|
4451 else |
|
4452 { |
|
4453 changed = ShowPopupSettingPageL( *ptr ); |
|
4454 } |
|
4455 if ( changed ) |
|
4456 { |
|
4457 if ( *ptr == EApGprsPdpType ) |
|
4458 { |
|
4459 HandleListboxDataChangeL( EFalse ); |
|
4460 } |
|
4461 UpdateOnOffListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4462 if ( *ptr == EApWlanNetworkMode ) |
|
4463 { |
|
4464 UpdateOnOffListBoxItemL( *( ptr+1 ), *( tptr+1 ), |
|
4465 itemnum+1, |
|
4466 *( compulsptr + 1 ) ); |
|
4467 if ( (itemnum+1) <= iList->BottomItemIndex() ) |
|
4468 { |
|
4469 iList->DrawItem( itemnum+1 ); |
|
4470 } |
|
4471 } |
|
4472 } |
|
4473 break; |
|
4474 } |
|
4475 case EApIspDefaultTelNumber: |
|
4476 case EApIspIfCallbackInfo: |
|
4477 { // type 1, Phone number editor |
|
4478 ShowPopupPhoneNumSettingPageL( *ptr ); |
|
4479 UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4480 break; |
|
4481 } |
|
4482 case EApWapGatewayAddress: |
|
4483 case EApIspIPAddr: |
|
4484 case EApIspIPNetMask: |
|
4485 case EApWlanIpNetMask: |
|
4486 case EApIspIPGateway: |
|
4487 case EApWlanIpGateway: |
|
4488 case EApGprsIPNameServer1: |
|
4489 case EApIspIPNameServer1: |
|
4490 case EApGprsIPNameServer2: |
|
4491 case EApIspIPNameServer2: |
|
4492 {// above ones are type 1, IP Address editors! |
|
4493 ShowPopupIpAddrSettingPageL( *ptr ); |
|
4494 UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4495 if ( *ptr == EApWapGatewayAddress ) |
|
4496 { |
|
4497 HandleListStructureChangeL(); |
|
4498 HandleListboxDataChangeL( EFalse ); |
|
4499 } |
|
4500 if ( *ptr == EApIspIPAddr ) |
|
4501 { |
|
4502 HandleListboxDataChangeL( EFalse ); |
|
4503 } |
|
4504 break; |
|
4505 } |
|
4506 case EApWapAccessPointName: |
|
4507 case EApGprsAccessPointName: |
|
4508 case EApIspLoginName: |
|
4509 case EApIspIfAuthName: |
|
4510 case EApIspLoginScript: |
|
4511 case EApWapStartPage: |
|
4512 case EApIspInitString: |
|
4513 case EApProxyServerAddress: |
|
4514 case EApProxyPortNumber: |
|
4515 { // type 1, Text setting item |
|
4516 if ( ShowPopupTextSettingPageL( *ptr ) ) |
|
4517 { |
|
4518 UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4519 if ( *ptr == EApWapAccessPointName ) |
|
4520 { |
|
4521 iTitlePane->SetTextL( iApItem->ConnectionName() ); |
|
4522 } |
|
4523 } |
|
4524 break; |
|
4525 } |
|
4526 case EApIspLoginPass: |
|
4527 case EApIspIfAuthPass: |
|
4528 |
|
4529 { // re-confirm, secreted, etc, |
|
4530 ShowPopupPasswordPageL( *ptr ); |
|
4531 UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4532 break; |
|
4533 } |
|
4534 case EApWapCurrentBearer: |
|
4535 case EApIspBearerCallTypeIsdn: // used for data call type |
|
4536 case EApIspBearerSpeed: |
|
4537 case EApWlanChannelId: |
|
4538 { // type 2, Pop-up setting item |
|
4539 if ( ShowPopupSettingPageL( *ptr ) ) |
|
4540 { |
|
4541 if ( *ptr == EApWapCurrentBearer ) |
|
4542 { |
|
4543 // if ==, the whole list needs to be updated ! |
|
4544 SetBearerTypeL( iApItem->BearerTypeL() ); |
|
4545 LimitSpeed(); |
|
4546 HandleListboxDataChangeL( EFalse ); |
|
4547 iList->SetTopItemIndex( topitem ); |
|
4548 iList->DrawNow(); |
|
4549 } |
|
4550 else |
|
4551 { |
|
4552 if ( *ptr == EApIspBearerCallTypeIsdn ) |
|
4553 { // first limit the speed if neccessary |
|
4554 LimitSpeed(); |
|
4555 // need to redraw EApIspBearerSpeed, too |
|
4556 // because it is possible that it had been changed |
|
4557 // to keep constrains simply update next field, |
|
4558 // too, 'cause they are next to each other... |
|
4559 UpdateOnOffListBoxItemL( *( ptr+1 ), *( tptr+1 ), |
|
4560 itemnum+1, |
|
4561 *( compulsptr + 1 ) ); |
|
4562 iList->DrawItem( itemnum+1 ); |
|
4563 } |
|
4564 UpdateOnOffListBoxItemL( *ptr, *tptr, |
|
4565 itemnum, *compulsptr ); |
|
4566 } |
|
4567 } |
|
4568 break; |
|
4569 } |
|
4570 case EApWlanSecurityMode: |
|
4571 { // type 2, Pop-up setting item |
|
4572 if ( ShowPopupSettingPageL( *ptr ) ) |
|
4573 { |
|
4574 // security mode has changed, re-create security settings! |
|
4575 UpdateOnOffListBoxItemL( *ptr, *tptr, |
|
4576 itemnum, *compulsptr ); |
|
4577 iHandler->iModel->UpdateSecurityModeL( *iApItem ); |
|
4578 } |
|
4579 break; |
|
4580 } |
|
4581 case EApIP6DNSAddrFromServer: |
|
4582 { |
|
4583 // if GPRS, PDP type Ipv4, DNS data query |
|
4584 // if GPRS, PDP type Ipv6, type 2, Pop-up setting item |
|
4585 TUint32 ival(0); |
|
4586 iApItem->ReadUint( EApGprsPdpType, ival ); |
|
4587 TBool changed( EFalse ); |
|
4588 if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) |
|
4589 { |
|
4590 if ( ival == EIPv6 ) |
|
4591 { |
|
4592 // GPRS, PDP type Ipv6, DNS pop-up setting item |
|
4593 changed = ShowPopupSettingPageL( *ptr ); |
|
4594 } |
|
4595 else |
|
4596 { |
|
4597 // GPRS, PDP type Ipv4, DNS data query |
|
4598 changed = GetNameServersL( EFalse ); |
|
4599 } |
|
4600 } |
|
4601 else |
|
4602 { // CSD/HSCSD |
|
4603 if ( iL2Ipv4 ) |
|
4604 { |
|
4605 changed = GetNameServersL( EFalse ); |
|
4606 } |
|
4607 else |
|
4608 { |
|
4609 changed = ShowPopupSettingPageL( *ptr ); |
|
4610 } |
|
4611 } |
|
4612 if ( changed ) |
|
4613 { |
|
4614 UpdateOnOffListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4615 } |
|
4616 break; |
|
4617 } |
|
4618 case EApNetworkName: |
|
4619 { |
|
4620 ChangeNetworkGroupL(); |
|
4621 UpdateTextualListBoxItemL( *ptr, *tptr, itemnum, *compulsptr ); |
|
4622 break; |
|
4623 } |
|
4624 case EApIpv4Settings: |
|
4625 case EApIpv6Settings: |
|
4626 { |
|
4627 iL2Ipv4 = ( *ptr == EApIpv4Settings ); |
|
4628 if ( iLevel ) |
|
4629 { |
|
4630 // enter Ipv4 or Ipv6 settings |
|
4631 if ( iL2Ipv4 ) |
|
4632 { |
|
4633 // save current state so we can roll back to it |
|
4634 // if needed, e.g. if user fills but discards values... |
|
4635 if (!iBackupApItem ) |
|
4636 { |
|
4637 iBackupApItem = CApAccessPointItem::NewLC(); |
|
4638 CleanupStack::Pop(); // member var |
|
4639 } |
|
4640 iBackupApItem->CopyFromL( *iApItem ); |
|
4641 } |
|
4642 iLevel++; |
|
4643 HandleListStructureChangeL(); |
|
4644 iOldIndex = iList->CurrentItemIndex(); |
|
4645 iOldTopIndex = iList->TopItemIndex(); |
|
4646 iList->SetCurrentItemIndex( 0 ); |
|
4647 HandleListboxDataChangeL( EFalse ); |
|
4648 itemnum = 0; |
|
4649 } |
|
4650 break; |
|
4651 } |
|
4652 case EApWlanNetworkName: |
|
4653 { |
|
4654 if ( IsWlanSupported() ) |
|
4655 { |
|
4656 // Temporarily use plain text editor to input |
|
4657 // network name... |
|
4658 ChangeWlanNetworkNameL(); |
|
4659 // as it sets connection mode and security mode, |
|
4660 // we must update the full list... |
|
4661 HandleListboxDataChangeL( EFalse ); |
|
4662 } |
|
4663 else |
|
4664 { |
|
4665 User::Leave( KErrNotSupported ); |
|
4666 } |
|
4667 break; |
|
4668 } |
|
4669 case EApWlanSecuritySettings: |
|
4670 { |
|
4671 if ( IsWlanSupported() ) |
|
4672 { |
|
4673 iSecSettingsExitReason = ChangeWlanSecuritySettingsL(); |
|
4674 } |
|
4675 else |
|
4676 { |
|
4677 User::Leave( KErrNotSupported ); |
|
4678 } |
|
4679 break; |
|
4680 } |
|
4681 /* |
|
4682 case EApWlanChannelId: |
|
4683 { |
|
4684 breaaak; |
|
4685 } |
|
4686 */ |
|
4687 default: |
|
4688 { |
|
4689 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4690 break; |
|
4691 } |
|
4692 } |
|
4693 SelectItem( itemnum ); |
|
4694 |
|
4695 APSETUILOGGER_LEAVEFN( ESettings,"Settings::DoChangeSettingsL") |
|
4696 } |
|
4697 |
|
4698 |
|
4699 |
|
4700 |
|
4701 //---------------------------------------------------------- |
|
4702 // CApSettingsDlg::GetSpeedForSelection |
|
4703 //---------------------------------------------------------- |
|
4704 // |
|
4705 TApCallSpeed CApSettingsDlg::GetBearerSpeedForSelection( TInt aCurrvalue ) |
|
4706 { |
|
4707 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetBearerSpeedForSelection") |
|
4708 |
|
4709 TApCallSpeed sp( KSpeed9600 ); |
|
4710 |
|
4711 |
|
4712 TUint32 tval( 0 ); |
|
4713 iApItem->ReadUint( EApIspBearerCallTypeIsdn, tval ); |
|
4714 |
|
4715 const TInt* actSpeeds = NULL; |
|
4716 TBool isWcdma = |
|
4717 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); |
|
4718 |
|
4719 switch ( tval ) |
|
4720 { |
|
4721 case ECallTypeAnalogue: |
|
4722 { // CSD/HSCSD, Analogue |
|
4723 switch ( iBearerType ) |
|
4724 { |
|
4725 case EApBearerTypeCSD: |
|
4726 { |
|
4727 actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; |
|
4728 break; |
|
4729 } |
|
4730 case EApBearerTypeHSCSD: |
|
4731 { |
|
4732 actSpeeds = KHcsdAnalogue; |
|
4733 break; |
|
4734 } |
|
4735 default: |
|
4736 { |
|
4737 // this can only mean programmer error as no other |
|
4738 // bearer type is supperted with speed settings |
|
4739 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4740 break; |
|
4741 } |
|
4742 } |
|
4743 break; |
|
4744 } |
|
4745 case ECallTypeISDNv110: |
|
4746 { |
|
4747 switch ( iBearerType ) |
|
4748 { |
|
4749 case EApBearerTypeCSD: |
|
4750 { |
|
4751 actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; |
|
4752 break; |
|
4753 } |
|
4754 case EApBearerTypeHSCSD: |
|
4755 { |
|
4756 actSpeeds = KHcsdIsdn110; |
|
4757 break; |
|
4758 } |
|
4759 default: |
|
4760 { |
|
4761 // this can only mean programmer error as no other |
|
4762 // bearer type is supperted with speed settings |
|
4763 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4764 break; |
|
4765 } |
|
4766 } |
|
4767 break; |
|
4768 } |
|
4769 case ECallTypeISDNv120: |
|
4770 { |
|
4771 switch ( iBearerType ) |
|
4772 { |
|
4773 case EApBearerTypeCSD: |
|
4774 { |
|
4775 actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; |
|
4776 break; |
|
4777 } |
|
4778 case EApBearerTypeHSCSD: |
|
4779 { |
|
4780 actSpeeds = KHcsdIsdn120; |
|
4781 break; |
|
4782 } |
|
4783 default: |
|
4784 { |
|
4785 // this can only mean programmer error as no other |
|
4786 // bearer type is supperted with speed settings |
|
4787 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4788 break; |
|
4789 } |
|
4790 } |
|
4791 break; |
|
4792 } |
|
4793 default: |
|
4794 { |
|
4795 // this can only mean programmer error as no other |
|
4796 // bearer type is supperted with speed settings |
|
4797 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4798 break; |
|
4799 } |
|
4800 } |
|
4801 |
|
4802 sp = (TApCallSpeed) *(actSpeeds + aCurrvalue); |
|
4803 |
|
4804 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetBearerSpeedForSelection") |
|
4805 return sp; |
|
4806 } |
|
4807 |
|
4808 |
|
4809 |
|
4810 //---------------------------------------------------------- |
|
4811 // CApSettingsDlg::GetCurrIndexFromBearerSpeed |
|
4812 //---------------------------------------------------------- |
|
4813 // |
|
4814 TInt CApSettingsDlg::GetCurrIndexFromBearerSpeed( ) |
|
4815 { |
|
4816 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetCurrIndexFromBearerSpeed") |
|
4817 |
|
4818 TUint32 tval( 0 ); |
|
4819 TUint32 bval( 0 ); |
|
4820 TInt retval( 0 ); |
|
4821 |
|
4822 iApItem->ReadUint( EApIspBearerSpeed, tval ); |
|
4823 iApItem->ReadUint( EApIspBearerCallTypeIsdn, bval ); |
|
4824 |
|
4825 TBool isWcdma = |
|
4826 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); |
|
4827 |
|
4828 const TInt* actSpeeds = NULL; |
|
4829 |
|
4830 switch ( bval ) |
|
4831 { |
|
4832 case ECallTypeAnalogue: |
|
4833 { // CSD/HSCSD, Analogue |
|
4834 switch ( iBearerType ) |
|
4835 { |
|
4836 case EApBearerTypeCSD: |
|
4837 { |
|
4838 actSpeeds = isWcdma ? KCsdAnalogueWcdma : KCsdAnalogue; |
|
4839 break; |
|
4840 } |
|
4841 case EApBearerTypeHSCSD: |
|
4842 { |
|
4843 actSpeeds = KHcsdAnalogue; |
|
4844 break; |
|
4845 } |
|
4846 default: |
|
4847 { |
|
4848 // this can only mean programmer error as no other |
|
4849 // bearer type is supperted with speed settings |
|
4850 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4851 break; |
|
4852 } |
|
4853 } |
|
4854 break; |
|
4855 } |
|
4856 case ECallTypeISDNv110: |
|
4857 { |
|
4858 switch ( iBearerType ) |
|
4859 { |
|
4860 case EApBearerTypeCSD: |
|
4861 { |
|
4862 actSpeeds = isWcdma ? KCsdIsdn110Wcdma : KCsdIsdn110; |
|
4863 break; |
|
4864 } |
|
4865 case EApBearerTypeHSCSD: |
|
4866 { |
|
4867 actSpeeds = KHcsdIsdn110; |
|
4868 break; |
|
4869 } |
|
4870 default: |
|
4871 { |
|
4872 // this can only mean programmer error as no other |
|
4873 // bearer type is supperted with speed settings |
|
4874 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4875 break; |
|
4876 } |
|
4877 } |
|
4878 break; |
|
4879 } |
|
4880 case ECallTypeISDNv120: |
|
4881 { |
|
4882 switch ( iBearerType ) |
|
4883 { |
|
4884 case EApBearerTypeCSD: |
|
4885 { |
|
4886 actSpeeds = isWcdma ? KCsdIsdn120Wcdma : KCsdIsdn120; |
|
4887 break; |
|
4888 } |
|
4889 case EApBearerTypeHSCSD: |
|
4890 { |
|
4891 actSpeeds = KHcsdIsdn120; |
|
4892 break; |
|
4893 } |
|
4894 default: |
|
4895 { |
|
4896 // this can only mean programmer error as no other |
|
4897 // bearer type is supperted with speed settings |
|
4898 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4899 break; |
|
4900 } |
|
4901 } |
|
4902 break; |
|
4903 } |
|
4904 default: |
|
4905 { |
|
4906 // this can only mean programmer error as no other |
|
4907 // bearer type is supperted with speed settings |
|
4908 __ASSERT_DEBUG( EFalse, Panic( EUnknownCase ) ); |
|
4909 break; |
|
4910 } |
|
4911 } |
|
4912 |
|
4913 if( actSpeeds ) |
|
4914 { |
|
4915 retval = 0; |
|
4916 while ( ( *( actSpeeds + retval + 1) != KEndOfArray ) |
|
4917 && ( *( actSpeeds + retval) < ( TInt )tval ) |
|
4918 && ( *( actSpeeds + retval + 1) <= ( TInt )tval ) ) |
|
4919 { |
|
4920 ++retval; |
|
4921 } |
|
4922 } |
|
4923 |
|
4924 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetCurrIndexFromBearerSpeed") |
|
4925 return retval; |
|
4926 } |
|
4927 |
|
4928 |
|
4929 //---------------------------------------------------------- |
|
4930 // CApSettingsDlg::ReplaceNonPrintingCharactersLC |
|
4931 //---------------------------------------------------------- |
|
4932 // |
|
4933 HBufC* CApSettingsDlg::ReplaceWhiteSpaceCharactersLC( const TDesC& aInText ) |
|
4934 { |
|
4935 APSETUILOGGER_ENTERFN( ESettings,"Settings::ReplaceWhiteSpaceCharactersLC") |
|
4936 |
|
4937 TInt size = aInText.Length(); |
|
4938 HBufC* aOutText = HBufC::NewLC( size ); |
|
4939 |
|
4940 TPtr ptr = aOutText->Des(); |
|
4941 |
|
4942 for ( TInt ii=0; ii<size; ++ii ) |
|
4943 { |
|
4944 TChar ch = aInText[ii]; |
|
4945 if ( ch.IsSpace() ) |
|
4946 { |
|
4947 ch = ' '; |
|
4948 } |
|
4949 ptr.Append( ch ); |
|
4950 } |
|
4951 |
|
4952 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ReplaceWhiteSpaceCharactersLC") |
|
4953 return aOutText; |
|
4954 } |
|
4955 |
|
4956 |
|
4957 |
|
4958 //---------------------------------------------------------- |
|
4959 // CApSettingsDlg::ChangeNetworkGroupL |
|
4960 //---------------------------------------------------------- |
|
4961 // |
|
4962 void CApSettingsDlg::ChangeNetworkGroupL() |
|
4963 { |
|
4964 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeNetworkGroupL") |
|
4965 |
|
4966 HBufC* titlebuf; |
|
4967 |
|
4968 titlebuf = iHandler->iModel->EikEnv()->AllocReadResourceLC |
|
4969 ( |
|
4970 R_APUI_VIEW_NETWORK_GROUP |
|
4971 ); |
|
4972 |
|
4973 // needs this Dummy array to pass it to CAknSettingPage's constructor... |
|
4974 CDesCArrayFlat* aItemArray = new ( ELeave ) CDesCArrayFlat( 1 ); |
|
4975 CleanupStack::PushL( aItemArray ); |
|
4976 TUint32 prefUid( 0 ); |
|
4977 TInt currsel( -1 ); |
|
4978 iApItem->ReadUint( EApNetworkID, prefUid ); |
|
4979 |
|
4980 TInt prefInt( prefUid ); |
|
4981 CApNetSelPopupList* dlg = |
|
4982 CApNetSelPopupList::NewL( *iDataModel, *iHandler, currsel, |
|
4983 prefInt, *iEventStore, |
|
4984 aItemArray, ETrue ); |
|
4985 |
|
4986 CleanupStack::PushL( dlg ); |
|
4987 TPtrC ptr( titlebuf->Des() ); |
|
4988 dlg->SetSettingTextL( ptr ); |
|
4989 // dlg must be Pop-ed because ExecuteLD starts with PushL()... |
|
4990 CleanupStack::Pop(); |
|
4991 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) ) |
|
4992 { |
|
4993 // update value in iApItem |
|
4994 // get networkitem and add it to item... |
|
4995 iApItem->WriteUint( EApNetworkID, prefInt ); |
|
4996 // update network data according to new ID |
|
4997 iDataModel->DataHandler()->ReadNetworkPartL( *iApItem ); |
|
4998 } |
|
4999 CleanupStack::PopAndDestroy( aItemArray ); // aItemArray |
|
5000 CleanupStack::PopAndDestroy( titlebuf ); // titlebuf |
|
5001 |
|
5002 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeNetworkGroupL") |
|
5003 } |
|
5004 |
|
5005 |
|
5006 |
|
5007 |
|
5008 //---------------------------------------------------------- |
|
5009 // CApSettingsDlg::IsHSCSDEnabledL |
|
5010 //---------------------------------------------------------- |
|
5011 // |
|
5012 TInt CApSettingsDlg::IsHSCSDEnabledL() |
|
5013 { |
|
5014 APSETUILOGGER_ENTERFN( ESettings,"Settings::IsHSCSDEnabledL") |
|
5015 |
|
5016 TInt EnableHSCSD( ETrue ); |
|
5017 |
|
5018 /* |
|
5019 // Connecting and initialization: |
|
5020 TInt err( KErrNone ); |
|
5021 CRepository* repository; |
|
5022 TRAP( err, repository = CRepository::NewL( KGeneralSettingsUid ) ); |
|
5023 // repository->Get( KGSHSCSDAccessPoints, EnableHSCSD ); |
|
5024 delete repository; |
|
5025 */ |
|
5026 |
|
5027 #ifdef __TEST_NO_HSCSD |
|
5028 EnableHSCSD = EFalse; |
|
5029 #endif |
|
5030 #ifdef __TEST_HSCSD_SUPPORT |
|
5031 EnableHSCSD = ETrue; |
|
5032 #endif // __TEST_HSCSD_SUPPORT |
|
5033 |
|
5034 APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsHSCSDEnabledL") |
|
5035 return EnableHSCSD; |
|
5036 } |
|
5037 |
|
5038 |
|
5039 |
|
5040 |
|
5041 |
|
5042 |
|
5043 |
|
5044 //---------------------------------------------------------- |
|
5045 // CApSettingsDlg::GetCSDSettingArrays |
|
5046 //---------------------------------------------------------- |
|
5047 // |
|
5048 void CApSettingsDlg::GetCSDSettingArrays( TInt variant ) |
|
5049 { |
|
5050 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetCSDSettingArrays") |
|
5051 |
|
5052 // If IPv6 support requested, is the only place where L2 level needed, |
|
5053 // so it is the only place when it is variated... |
|
5054 if ( iReqIpvType & EIPv6 ) |
|
5055 { |
|
5056 if ( iL2Ipv4 ) |
|
5057 { |
|
5058 iFieldL2 = |
|
5059 (TApMember*) &Fields_CSD_L2_IPv4[KApMember][0]; |
|
5060 iFieldCountL2 = |
|
5061 sizeof( Fields_CSD_L2_IPv4[KApMember] )/sizeof( TApMember ); |
|
5062 iTitlesL2 = |
|
5063 MUTABLE_CAST( TInt*, |
|
5064 &Fields_CSD_L2_IPv4[KResourceID][0] ); |
|
5065 iCompulsoryL2 = |
|
5066 MUTABLE_CAST( TInt*, |
|
5067 &Fields_CSD_L2_IPv4[KCompulsory][0] ); |
|
5068 } |
|
5069 else |
|
5070 { |
|
5071 iFieldL2 = |
|
5072 (TApMember*) &Fields_CSD_L2_IPv6[KApMember][0]; |
|
5073 iFieldCountL2 = |
|
5074 sizeof( Fields_CSD_L2_IPv6[KApMember] )/sizeof( TApMember ); |
|
5075 iTitlesL2 = |
|
5076 MUTABLE_CAST( TInt*, |
|
5077 &Fields_CSD_L2_IPv6[KResourceID][0] ); |
|
5078 iCompulsoryL2 = |
|
5079 MUTABLE_CAST( TInt*, |
|
5080 &Fields_CSD_L2_IPv6[KCompulsory][0] ); |
|
5081 } |
|
5082 } |
|
5083 |
|
5084 |
|
5085 |
|
5086 if ( variant & KWSPSettingsVisible ) |
|
5087 { |
|
5088 if ( iReqIpvType & EIPv6 ) |
|
5089 { |
|
5090 iField = (TApMember*) &Fields_CSD_WSP_IPv6[KApMember][0]; |
|
5091 iFieldCount = |
|
5092 sizeof( Fields_CSD_WSP_IPv6[KApMember] )/sizeof( TApMember ); |
|
5093 |
|
5094 iFieldAdvanced = |
|
5095 (TApMember*) &Fields_CSD_Advanced_WSP_IPv6[KApMember][0]; |
|
5096 iAdvancedFieldCount = |
|
5097 sizeof( Fields_CSD_Advanced_WSP_IPv6[KApMember] ) |
|
5098 / sizeof( TApMember ); |
|
5099 |
|
5100 iTitles = |
|
5101 MUTABLE_CAST( TInt*, &Fields_CSD_WSP_IPv6[KResourceID][0] ); |
|
5102 iTitlesAdvanced = |
|
5103 MUTABLE_CAST( TInt*, |
|
5104 &Fields_CSD_Advanced_WSP_IPv6[KResourceID][0] ); |
|
5105 |
|
5106 iCompulsory = |
|
5107 MUTABLE_CAST( TInt*, |
|
5108 &Fields_CSD_WSP_IPv6[KCompulsory][0] ); |
|
5109 iCompulsoryAdvanced = |
|
5110 MUTABLE_CAST( TInt*, |
|
5111 &Fields_CSD_Advanced_WSP_IPv6[KCompulsory][0] ); |
|
5112 |
|
5113 } |
|
5114 else |
|
5115 { |
|
5116 iField = (TApMember*) &Fields_CSD_WSP[KApMember][0]; |
|
5117 iFieldCount = |
|
5118 sizeof( Fields_CSD_WSP[KApMember] )/sizeof( TApMember ); |
|
5119 |
|
5120 iFieldAdvanced = |
|
5121 (TApMember*) &Fields_CSD_Advanced_WSP[KApMember][0]; |
|
5122 iAdvancedFieldCount = |
|
5123 sizeof( Fields_CSD_Advanced_WSP[KApMember] ) |
|
5124 / sizeof( TApMember ); |
|
5125 |
|
5126 iTitles = |
|
5127 MUTABLE_CAST( TInt*, &Fields_CSD_WSP[KResourceID][0] ); |
|
5128 iTitlesAdvanced = |
|
5129 MUTABLE_CAST( TInt*, |
|
5130 &Fields_CSD_Advanced_WSP[KResourceID][0] ); |
|
5131 |
|
5132 iCompulsory = |
|
5133 MUTABLE_CAST( TInt*, &Fields_CSD_WSP[KCompulsory][0] ); |
|
5134 iCompulsoryAdvanced = |
|
5135 MUTABLE_CAST( TInt*, |
|
5136 &Fields_CSD_Advanced_WSP[KCompulsory][0] ); |
|
5137 } |
|
5138 } |
|
5139 else |
|
5140 { |
|
5141 if ( iReqIpvType & EIPv6 ) |
|
5142 { |
|
5143 iField = (TApMember*) &Fields_CSD_IPv6[KApMember][0]; |
|
5144 iFieldCount = |
|
5145 sizeof( Fields_CSD_IPv6[KApMember] )/sizeof( TApMember ); |
|
5146 |
|
5147 iFieldAdvanced = |
|
5148 (TApMember*) &Fields_CSD_Advanced_IPv6[KApMember][0]; |
|
5149 iAdvancedFieldCount = |
|
5150 sizeof( Fields_CSD_Advanced_IPv6[KApMember] ) |
|
5151 / sizeof( TApMember ); |
|
5152 |
|
5153 iTitles = |
|
5154 MUTABLE_CAST( TInt*, |
|
5155 &Fields_CSD_IPv6[KResourceID][0] ); |
|
5156 iTitlesAdvanced = |
|
5157 MUTABLE_CAST( TInt*, |
|
5158 &Fields_CSD_Advanced_IPv6[KResourceID][0] ); |
|
5159 |
|
5160 iCompulsory = |
|
5161 MUTABLE_CAST( TInt*, |
|
5162 &Fields_CSD_IPv6[KCompulsory][0] ); |
|
5163 iCompulsoryAdvanced = |
|
5164 MUTABLE_CAST( TInt*, |
|
5165 &Fields_CSD_Advanced_IPv6[KCompulsory][0] ); |
|
5166 } |
|
5167 else |
|
5168 { |
|
5169 iField = (TApMember*) &Fields_CSD[KApMember][0]; |
|
5170 iFieldCount = sizeof( Fields_CSD[KApMember] )/sizeof( TApMember ); |
|
5171 |
|
5172 iFieldAdvanced = (TApMember*) &Fields_CSD_Advanced[KApMember][0]; |
|
5173 iAdvancedFieldCount = |
|
5174 sizeof( Fields_CSD_Advanced[KApMember] )/sizeof( TApMember ); |
|
5175 |
|
5176 iTitles = MUTABLE_CAST( TInt*, &Fields_CSD[KResourceID][0] ); |
|
5177 iTitlesAdvanced = |
|
5178 MUTABLE_CAST( TInt*, &Fields_CSD_Advanced[KResourceID][0] ); |
|
5179 |
|
5180 iCompulsory = MUTABLE_CAST( TInt*, &Fields_CSD[KCompulsory][0] ); |
|
5181 iCompulsoryAdvanced = |
|
5182 MUTABLE_CAST( TInt*, &Fields_CSD_Advanced[KCompulsory][0] ); |
|
5183 } |
|
5184 } |
|
5185 |
|
5186 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetCSDSettingArrays") |
|
5187 } |
|
5188 |
|
5189 |
|
5190 |
|
5191 //---------------------------------------------------------- |
|
5192 // CApSettingsDlg::GetGPRSSettingArrays |
|
5193 //---------------------------------------------------------- |
|
5194 // |
|
5195 void CApSettingsDlg::GetGPRSSettingArrays( TInt variant ) |
|
5196 { |
|
5197 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetGPRSSettingArrays") |
|
5198 |
|
5199 if ( variant & KWSPSettingsVisible ) |
|
5200 { |
|
5201 if ( iReqIpvType & EIPv6 ) |
|
5202 { |
|
5203 iField = ( TApMember* ) &Fields_GPRS_WSP_IPv6[ KApMember ][0]; |
|
5204 iFieldCount = sizeof( Fields_GPRS_WSP_IPv6[0] ) |
|
5205 / sizeof( TApMember ); |
|
5206 iFieldAdvanced = |
|
5207 ( TApMember* ) &Fields_GPRS_Advanced_WSP_IPv6[ KApMember ][0]; |
|
5208 iAdvancedFieldCount = |
|
5209 sizeof( Fields_GPRS_Advanced_WSP_IPv6[ KApMember ]) |
|
5210 / sizeof( TApMember ); |
|
5211 iTitles = |
|
5212 MUTABLE_CAST( TInt*, &Fields_GPRS_WSP_IPv6[ KResourceID ][0] ); |
|
5213 iTitlesAdvanced = |
|
5214 MUTABLE_CAST( |
|
5215 TInt*, |
|
5216 &Fields_GPRS_Advanced_WSP_IPv6[ KResourceID ][0] ); |
|
5217 iCompulsory = |
|
5218 MUTABLE_CAST( TInt*, &Fields_GPRS_WSP_IPv6[ KCompulsory ][0] ); |
|
5219 iCompulsoryAdvanced = |
|
5220 MUTABLE_CAST( |
|
5221 TInt*, |
|
5222 &Fields_GPRS_Advanced_WSP_IPv6[ KCompulsory ][0] ); |
|
5223 } |
|
5224 else |
|
5225 { |
|
5226 iField = ( TApMember* ) &Fields_GPRS_WSP[ KApMember ][0]; |
|
5227 iFieldCount = sizeof( Fields_GPRS_WSP[0] )/sizeof( TApMember ); |
|
5228 iFieldAdvanced = |
|
5229 ( TApMember* ) &Fields_GPRS_Advanced_WSP[ KApMember ][0]; |
|
5230 iAdvancedFieldCount = |
|
5231 sizeof( Fields_GPRS_Advanced_WSP[ KApMember ]) |
|
5232 / sizeof( TApMember ); |
|
5233 iTitles = |
|
5234 MUTABLE_CAST( TInt*, &Fields_GPRS_WSP[ KResourceID ][0] ); |
|
5235 iTitlesAdvanced = |
|
5236 MUTABLE_CAST( |
|
5237 TInt*, |
|
5238 &Fields_GPRS_Advanced_WSP[ KResourceID ][0] ); |
|
5239 iCompulsory = |
|
5240 MUTABLE_CAST( TInt*, &Fields_GPRS_WSP[ KCompulsory ][0] ); |
|
5241 iCompulsoryAdvanced = |
|
5242 MUTABLE_CAST( |
|
5243 TInt*, |
|
5244 &Fields_GPRS_Advanced_WSP[ KCompulsory ][0] ); |
|
5245 } |
|
5246 } |
|
5247 else |
|
5248 { |
|
5249 if ( iReqIpvType & EIPv6 ) |
|
5250 { |
|
5251 iField = ( TApMember* ) &Fields_GPRS_IPv6[ KApMember ][0]; |
|
5252 iFieldCount = sizeof( Fields_GPRS_IPv6[0] )/sizeof( TApMember ); |
|
5253 iFieldAdvanced = |
|
5254 ( TApMember* ) &Fields_GPRS_Advanced_IPv6[ KApMember ][0]; |
|
5255 iAdvancedFieldCount = |
|
5256 sizeof( Fields_GPRS_Advanced_IPv6[ KApMember ]) |
|
5257 / sizeof( TApMember ); |
|
5258 iTitles = |
|
5259 MUTABLE_CAST( TInt*, &Fields_GPRS_IPv6[ KResourceID ][0] ); |
|
5260 iTitlesAdvanced = |
|
5261 MUTABLE_CAST( TInt*, |
|
5262 &Fields_GPRS_Advanced_IPv6[ KResourceID ][0] ); |
|
5263 iCompulsory = |
|
5264 MUTABLE_CAST( TInt*, &Fields_GPRS_IPv6[ KCompulsory ][0] ); |
|
5265 iCompulsoryAdvanced = |
|
5266 MUTABLE_CAST( TInt*, |
|
5267 &Fields_GPRS_Advanced_IPv6[ KCompulsory ][0] ); |
|
5268 } |
|
5269 else |
|
5270 { |
|
5271 iField = ( TApMember* ) &Fields_GPRS[ KApMember ][0]; |
|
5272 iFieldCount = sizeof( Fields_GPRS[0] )/sizeof( TApMember ); |
|
5273 iFieldAdvanced = |
|
5274 ( TApMember* ) &Fields_GPRS_Advanced[ KApMember ][0]; |
|
5275 iAdvancedFieldCount = |
|
5276 sizeof( Fields_GPRS_Advanced[ KApMember ])/sizeof( TApMember ); |
|
5277 iTitles = |
|
5278 MUTABLE_CAST( TInt*, &Fields_GPRS[ KResourceID ][0] ); |
|
5279 iTitlesAdvanced = |
|
5280 MUTABLE_CAST( TInt*, &Fields_GPRS_Advanced[ KResourceID ][0] ); |
|
5281 iCompulsory = |
|
5282 MUTABLE_CAST( TInt*, &Fields_GPRS[ KCompulsory ][0] ); |
|
5283 iCompulsoryAdvanced = |
|
5284 MUTABLE_CAST( TInt*, &Fields_GPRS_Advanced[ KCompulsory ][0] ); |
|
5285 } |
|
5286 } |
|
5287 |
|
5288 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetGPRSSettingArrays") |
|
5289 } |
|
5290 |
|
5291 |
|
5292 |
|
5293 |
|
5294 //---------------------------------------------------------- |
|
5295 // CApSettingsDlg::GetWLANSettingArraysL |
|
5296 //---------------------------------------------------------- |
|
5297 // |
|
5298 void CApSettingsDlg::GetWLANSettingArraysL( TInt /*aVariant*/ ) |
|
5299 { |
|
5300 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetWLANSettingArraysL") |
|
5301 |
|
5302 if ( IsWlanSupported() ) |
|
5303 { |
|
5304 // If IPv6 support requested, is the only place where L2 level needed, |
|
5305 // so it is the only place when it is variated... |
|
5306 if ( iReqIpvType & EIPv6 ) |
|
5307 { |
|
5308 if ( iL2Ipv4 ) |
|
5309 { |
|
5310 iFieldL2 = |
|
5311 (TApMember*) &Fields_WLAN_L2_IPv4[KApMember][0]; |
|
5312 iFieldCountL2 = |
|
5313 sizeof( Fields_WLAN_L2_IPv4[KApMember] ) |
|
5314 / sizeof( TApMember ); |
|
5315 iTitlesL2 = |
|
5316 MUTABLE_CAST( TInt*, |
|
5317 &Fields_WLAN_L2_IPv4[KResourceID][0] ); |
|
5318 iCompulsoryL2 = |
|
5319 MUTABLE_CAST( TInt*, |
|
5320 &Fields_WLAN_L2_IPv4[KCompulsory][0] ); |
|
5321 } |
|
5322 else |
|
5323 { |
|
5324 iFieldL2 = |
|
5325 (TApMember*) &Fields_CSD_L2_IPv6[KApMember][0]; |
|
5326 iFieldCountL2 = |
|
5327 sizeof( Fields_CSD_L2_IPv6[KApMember] ) |
|
5328 / sizeof( TApMember ); |
|
5329 iTitlesL2 = |
|
5330 MUTABLE_CAST( TInt*, |
|
5331 &Fields_CSD_L2_IPv6[KResourceID][0] ); |
|
5332 iCompulsoryL2 = |
|
5333 MUTABLE_CAST( TInt*, |
|
5334 &Fields_CSD_L2_IPv6[KCompulsory][0] ); |
|
5335 } |
|
5336 } |
|
5337 |
|
5338 |
|
5339 if ( iReqIpvType & EIPv6 ) |
|
5340 { |
|
5341 iField = ( TApMember* ) &Fields_WLAN_IPv6[ KApMember ][0]; |
|
5342 iFieldCount = sizeof( Fields_WLAN_IPv6[0] )/sizeof( TApMember ); |
|
5343 iFieldAdvanced = |
|
5344 ( TApMember* ) &Fields_WLAN_Advanced_IPv6[ KApMember ][0]; |
|
5345 iAdvancedFieldCount = |
|
5346 sizeof( Fields_WLAN_Advanced_IPv6[ KApMember ]) |
|
5347 / sizeof( TApMember ); |
|
5348 iTitles = |
|
5349 MUTABLE_CAST( TInt*, &Fields_WLAN_IPv6[ KResourceID ][0] ); |
|
5350 iTitlesAdvanced = |
|
5351 MUTABLE_CAST( TInt*, |
|
5352 &Fields_WLAN_Advanced_IPv6[ KResourceID ][0] ); |
|
5353 iCompulsory = |
|
5354 MUTABLE_CAST( TInt*, &Fields_WLAN_IPv6[ KCompulsory ][0] ); |
|
5355 iCompulsoryAdvanced = |
|
5356 MUTABLE_CAST( TInt*, |
|
5357 &Fields_WLAN_Advanced_IPv6[ KCompulsory ][0] ); |
|
5358 } |
|
5359 else |
|
5360 { |
|
5361 iField = ( TApMember* ) &Fields_WLAN_IPv4[ KApMember ][0]; |
|
5362 iFieldCount = sizeof( Fields_WLAN_IPv4[0] )/sizeof( TApMember ); |
|
5363 iFieldAdvanced = |
|
5364 ( TApMember* ) &Fields_WLAN_Advanced_IPv4[ KApMember ][0]; |
|
5365 iAdvancedFieldCount = |
|
5366 sizeof( Fields_WLAN_Advanced_IPv4[ KApMember ]) |
|
5367 / sizeof( TApMember ); |
|
5368 iTitles = |
|
5369 MUTABLE_CAST( TInt*, &Fields_WLAN_IPv4[ KResourceID ][0] ); |
|
5370 iTitlesAdvanced = |
|
5371 MUTABLE_CAST( TInt*, |
|
5372 &Fields_WLAN_Advanced_IPv4[ KResourceID ][0] ); |
|
5373 iCompulsory = |
|
5374 MUTABLE_CAST( TInt*, &Fields_WLAN_IPv4[ KCompulsory ][0] ); |
|
5375 iCompulsoryAdvanced = |
|
5376 MUTABLE_CAST( TInt*, |
|
5377 &Fields_WLAN_Advanced_IPv4[ KCompulsory ][0] ); |
|
5378 } |
|
5379 } |
|
5380 else |
|
5381 { |
|
5382 User::Leave( KErrNotSupported ); |
|
5383 } |
|
5384 |
|
5385 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetWLANSettingArraysL") |
|
5386 } |
|
5387 |
|
5388 |
|
5389 |
|
5390 //---------------------------------------------------------- |
|
5391 // CApSettingsDlg::GetNameServersL |
|
5392 //---------------------------------------------------------- |
|
5393 // |
|
5394 TInt CApSettingsDlg::GetNameServersL( TBool aIp6 ) |
|
5395 { |
|
5396 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetNameServersL") |
|
5397 |
|
5398 TInt retval( 0 ); |
|
5399 |
|
5400 if ( (iReqIpvType & EIPv6) && aIp6 ) |
|
5401 { |
|
5402 retval = GetIpv6NameServerL(); |
|
5403 } |
|
5404 else |
|
5405 { |
|
5406 retval = GetIpv4NameServerL(); |
|
5407 } |
|
5408 |
|
5409 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetNameServersL") |
|
5410 return retval; |
|
5411 } |
|
5412 |
|
5413 |
|
5414 |
|
5415 |
|
5416 |
|
5417 |
|
5418 //---------------------------------------------------------- |
|
5419 // CApSettingsDlg::AddMenuListBoxItemL |
|
5420 //---------------------------------------------------------- |
|
5421 // |
|
5422 void CApSettingsDlg::AddMenuListBoxItemL( CDesCArrayFlat& aItemArray, |
|
5423 TApMember /*aMember*/, TInt aRes, |
|
5424 TInt aCompulsory ) |
|
5425 { |
|
5426 APSETUILOGGER_ENTERFN( ESettings,"Settings::AddMenuListBoxItemL") |
|
5427 |
|
5428 // Define a heap descriptor to hold all the item text |
|
5429 // HBufC is non-modifiable |
|
5430 HBufC* title = iEikonEnv->AllocReadResourceLC( aRes ); |
|
5431 |
|
5432 // Define a heap descriptor to hold all the item text |
|
5433 TInt length = title->Length() + 10; |
|
5434 if ( aCompulsory ) |
|
5435 { |
|
5436 length += 3; |
|
5437 } |
|
5438 HBufC* itemText = HBufC::NewLC( length ); |
|
5439 |
|
5440 |
|
5441 // Define a modifiable pointer descriptor to be able to append text to the |
|
5442 // non-modifiable heap descriptor itemText |
|
5443 TPtr itemTextPtr = itemText->Des(); |
|
5444 itemTextPtr.Format( KTxtMenuListItemFormat, title ); |
|
5445 if ( aCompulsory ) |
|
5446 { |
|
5447 itemTextPtr.Append( KTxtCompulsory ); |
|
5448 } |
|
5449 |
|
5450 aItemArray.AppendL( *itemText ); |
|
5451 CleanupStack::PopAndDestroy( itemText ); |
|
5452 CleanupStack::PopAndDestroy( title ); // title |
|
5453 |
|
5454 APSETUILOGGER_LEAVEFN( ESettings,"Settings::AddMenuListBoxItemL") |
|
5455 } |
|
5456 |
|
5457 |
|
5458 //---------------------------------------------------------- |
|
5459 // CApSettingsDlg::AskQueryIfWcdmaL |
|
5460 //---------------------------------------------------------- |
|
5461 // |
|
5462 TBool CApSettingsDlg::AskQueryIfWcdmaL( TApMember aMember, TInt aCurrvalue ) |
|
5463 { |
|
5464 APSETUILOGGER_ENTERFN( ESettings,"Settings::AskQueryIfWcdmaL") |
|
5465 |
|
5466 TBool accept = ETrue ; |
|
5467 TBool isWcdma = |
|
5468 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ); |
|
5469 if ( isWcdma && iBearerType == EApBearerTypeCSD && |
|
5470 aMember == EApIspBearerSpeed ) |
|
5471 { |
|
5472 TApCallSpeed newSpeed = GetBearerSpeedForSelection( aCurrvalue ); |
|
5473 switch ( newSpeed) |
|
5474 { |
|
5475 case KSpeed28800: |
|
5476 case KSpeed38400: |
|
5477 case KSpeed56000: |
|
5478 { |
|
5479 accept = AskQueryL( R_APUI_IAP_CONF_MAX_SPEED_WCDMA ); |
|
5480 break; |
|
5481 } |
|
5482 default: |
|
5483 { |
|
5484 break; |
|
5485 } |
|
5486 |
|
5487 } |
|
5488 } |
|
5489 |
|
5490 APSETUILOGGER_LEAVEFN( ESettings,"Settings::AskQueryIfWcdmaL") |
|
5491 return accept; |
|
5492 } |
|
5493 |
|
5494 |
|
5495 |
|
5496 //---------------------------------------------------------- |
|
5497 // CApSettingsDlg::GetDomainNameServersTypeL |
|
5498 //---------------------------------------------------------- |
|
5499 // |
|
5500 TInt CApSettingsDlg::GetDomainNameServersTypeL() |
|
5501 { |
|
5502 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetDomainNameServersTypeL") |
|
5503 |
|
5504 TInt retval( 0 ); |
|
5505 // GPRS, net type 4: |
|
5506 // if IspNameServ <> 0.0.0.0 => User defined |
|
5507 // GPRS, net type 6: |
|
5508 // if IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known |
|
5509 // CSD: |
|
5510 // if in IPv4settings: |
|
5511 // if IspNameServ <> 0.0.0.0 => User defined |
|
5512 // CSD: |
|
5513 // if in IPv6settings: |
|
5514 // if IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known |
|
5515 |
|
5516 if ( iApItem->BearerTypeL() == EApBearerTypeGPRS ) |
|
5517 { |
|
5518 TUint32 ipnettype( 0 ); |
|
5519 iApItem->ReadUint( EApGprsPdpType, ipnettype ); |
|
5520 if ( ipnettype == EIPv6 ) |
|
5521 { |
|
5522 retval = GetIPv6DNSTypeL(); |
|
5523 } |
|
5524 else |
|
5525 { |
|
5526 retval = GetIPv4DNSTypeL(); |
|
5527 } |
|
5528 } |
|
5529 else |
|
5530 { // CSD |
|
5531 // IPv4settings: IspNameServ <> 0.0.0.0 => User defined |
|
5532 // IPv6settings: |
|
5533 // IspIPv6NameServ <> 0.0.0.0 => User defined OR well-known |
|
5534 if ( iL2Ipv4 ) |
|
5535 { // IPv4 settings |
|
5536 retval = GetIPv4DNSTypeL(); |
|
5537 } |
|
5538 else |
|
5539 { // IPv6 settings |
|
5540 retval = GetIPv6DNSTypeL(); |
|
5541 } |
|
5542 } |
|
5543 |
|
5544 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetDomainNameServersTypeL") |
|
5545 return retval; |
|
5546 } |
|
5547 |
|
5548 |
|
5549 |
|
5550 //---------------------------------------------------------- |
|
5551 // CApSettingsDlg::GetIpv4NameServerL |
|
5552 //---------------------------------------------------------- |
|
5553 // |
|
5554 TInt CApSettingsDlg::GetIpv4NameServerL() |
|
5555 { |
|
5556 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIpv4NameServerL") |
|
5557 |
|
5558 HBufC* dns1 = HBufC::NewLC( KModifiableTextLength ); |
|
5559 HBufC* dns2 = HBufC::NewLC( KModifiableTextLength ); |
|
5560 TPtr dns1ptr( dns1->Des() ); |
|
5561 TPtr dns2ptr( dns2->Des() ); |
|
5562 |
|
5563 TInt ResId( 0 ); |
|
5564 |
|
5565 iApItem->ReadTextL( EApGprsIPNameServer1, dns1ptr ); |
|
5566 iApItem->ReadTextL( EApGprsIPNameServer2, dns2ptr ); |
|
5567 ResId = R_DNSIP4_QUERY; |
|
5568 |
|
5569 TInetAddr dns1Addr; |
|
5570 TInetAddr dns2Addr; |
|
5571 dns1Addr.Input( dns1ptr ); |
|
5572 dns2Addr.Input( dns2ptr ); |
|
5573 |
|
5574 CAknMultiLineIpQueryDialog* ipquery = |
|
5575 CAknMultiLineIpQueryDialog::NewL( dns1Addr, dns2Addr ); |
|
5576 |
|
5577 TInt retval = ipquery->ExecuteLD( ResId ); |
|
5578 if ( retval ) |
|
5579 { |
|
5580 dns1Addr.Output( dns1ptr ); |
|
5581 dns2Addr.Output( dns2ptr ); |
|
5582 if ( dns1ptr.Compare( KDynIpAddress ) == 0 ) |
|
5583 { // move 2nd to first, set second to Dynamic... |
|
5584 iApItem->WriteTextL( EApGprsIPNameServer1, dns2ptr ); |
|
5585 iApItem->WriteTextL( EApGprsIPNameServer2, KDynIpAddress ); |
|
5586 } |
|
5587 else |
|
5588 { |
|
5589 iApItem->WriteTextL( EApGprsIPNameServer1, dns1ptr ); |
|
5590 iApItem->WriteTextL( EApGprsIPNameServer2, dns2ptr ); |
|
5591 } |
|
5592 } |
|
5593 CleanupStack::PopAndDestroy( 2 ); // dns1, dns2 |
|
5594 |
|
5595 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIpv4NameServerL") |
|
5596 return retval; |
|
5597 } |
|
5598 |
|
5599 |
|
5600 //---------------------------------------------------------- |
|
5601 // CApSettingsDlg::GetIpv6NameServerL |
|
5602 //---------------------------------------------------------- |
|
5603 // |
|
5604 TInt CApSettingsDlg::GetIpv6NameServerL() |
|
5605 { |
|
5606 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIpv6NameServerL") |
|
5607 |
|
5608 HBufC* dns1 = HBufC::NewLC( KModifiableTextLength ); |
|
5609 HBufC* dns2 = HBufC::NewLC( KModifiableTextLength ); |
|
5610 TPtr dns1ptr( dns1->Des() ); |
|
5611 TPtr dns2ptr( dns2->Des() ); |
|
5612 |
|
5613 TInt ResId( 0 ); |
|
5614 |
|
5615 iApItem->ReadTextL( EApIP6NameServer1, dns1ptr ); |
|
5616 iApItem->ReadTextL( EApIP6NameServer2, dns2ptr ); |
|
5617 ResId = R_DNSIP6_QUERY; |
|
5618 |
|
5619 if ( ( dns1ptr.Compare( KKnownNameServer1 ) == 0 ) |
|
5620 && ( dns2ptr.Compare( KKnownNameServer2 ) == 0 ) ) |
|
5621 { // special value, well-known |
|
5622 // in this case 'dynamic' string must be offered so |
|
5623 // temp data must be changed to 'dynamic' |
|
5624 dns1ptr = KDynIpv6Address; |
|
5625 dns2ptr = KDynIpv6Address; |
|
5626 } |
|
5627 |
|
5628 CApMultiLineDataQueryDialog* ipquery = |
|
5629 CApMultiLineDataQueryDialog::NewL( dns1ptr, dns2ptr ); |
|
5630 |
|
5631 TInt retval = ipquery->ExecuteLD( ResId ); |
|
5632 if ( retval ) |
|
5633 { |
|
5634 TInetAddr dns1Addr; |
|
5635 TInetAddr dns2Addr; |
|
5636 TInt err1( KErrNone ); |
|
5637 TInt err2( KErrNone ); |
|
5638 if ( dns1ptr.Compare( KEmpty ) != 0 ) |
|
5639 { |
|
5640 err1 = dns1Addr.Input( dns1ptr ); |
|
5641 } |
|
5642 if ( dns2ptr.Compare( KEmpty ) != 0 ) |
|
5643 { |
|
5644 err2 = dns2Addr.Input( dns2ptr ); |
|
5645 } |
|
5646 if ( err1 || err2 ) |
|
5647 { |
|
5648 ShowNoteL( R_APUI_VIEW_SET_INFO_INVALID_IP ); |
|
5649 GetIpv6NameServerL(); |
|
5650 } |
|
5651 else |
|
5652 { |
|
5653 if ( |
|
5654 ( dns1ptr.Compare( KDynIpv6Address ) == 0 ) || |
|
5655 ( dns1ptr.Compare( KEmpty ) == 0 ) |
|
5656 ) |
|
5657 { // swap them: move 2nd to first, set second to Dynamic... |
|
5658 iApItem->WriteTextL( EApIP6NameServer1, dns2ptr ); |
|
5659 iApItem->WriteTextL( EApIP6NameServer2, KDynIpv6Address ); |
|
5660 } |
|
5661 else |
|
5662 { // keep the original order |
|
5663 iApItem->WriteTextL( EApIP6NameServer1, dns1ptr ); |
|
5664 iApItem->WriteTextL( EApIP6NameServer2, dns2ptr ); |
|
5665 } |
|
5666 } |
|
5667 } |
|
5668 CleanupStack::PopAndDestroy( 2 ); // dns1, dns2 |
|
5669 |
|
5670 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIpv6NameServerL") |
|
5671 return retval; |
|
5672 } |
|
5673 |
|
5674 |
|
5675 |
|
5676 //---------------------------------------------------------- |
|
5677 // CApSettingsDlg::GetIPv6DNSTypeL |
|
5678 //---------------------------------------------------------- |
|
5679 // |
|
5680 TInt CApSettingsDlg::GetIPv6DNSTypeL() |
|
5681 { |
|
5682 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIPv6DNSTypeL") |
|
5683 |
|
5684 TInt retval( 0 ); |
|
5685 |
|
5686 HBufC* buf1 = HBufC::NewLC( KModifiableTextLength ); |
|
5687 TPtr16 ptr1( buf1->Des() ); |
|
5688 |
|
5689 HBufC* buf2 = HBufC::NewLC( KModifiableTextLength ); |
|
5690 TPtr16 ptr2( buf2->Des() ); |
|
5691 |
|
5692 // net type 6: if IspIPv6NameServ <> 0.0.0.0 |
|
5693 // => User defined OR well-known |
|
5694 iApItem->ReadTextL( EApIP6NameServer1, ptr1 ); |
|
5695 iApItem->ReadTextL( EApIP6NameServer2, ptr2 ); |
|
5696 |
|
5697 if ( ( ptr1.Compare( KKnownNameServer1 ) == 0 ) |
|
5698 && ( ptr2.Compare( KKnownNameServer2 ) == 0 ) ) |
|
5699 { // special value, well-known |
|
5700 retval = 1; |
|
5701 } |
|
5702 else |
|
5703 { |
|
5704 // dynamic, if 0:0:... |
|
5705 // OR EMPTY text... |
|
5706 if ( ( ( ptr1.Compare( KDynIpv6Address ) == 0 ) |
|
5707 || ( ptr1.Compare( KEmpty ) == 0 ) ) |
|
5708 &&( ( ptr2.Compare( KDynIpv6Address ) == 0 ) |
|
5709 ||( ptr2.Compare( KEmpty ) == 0 ) ) ) |
|
5710 { // dynamic, 0:0:... |
|
5711 // OR in case of CSD, HSCSD, it might be user defined, |
|
5712 // as for those bearers Dynamic is not possible... |
|
5713 TApBearerType bt = iApItem->BearerTypeL(); |
|
5714 switch (bt) |
|
5715 { |
|
5716 case EApBearerTypeCSD: |
|
5717 case EApBearerTypeHSCSD: |
|
5718 { |
|
5719 retval = 2; // consider it user defined |
|
5720 break; |
|
5721 } |
|
5722 default: |
|
5723 { |
|
5724 retval = 0; |
|
5725 break; |
|
5726 } |
|
5727 } |
|
5728 } |
|
5729 else |
|
5730 { // other value, user defined |
|
5731 retval = 2; |
|
5732 } |
|
5733 } |
|
5734 |
|
5735 CleanupStack::PopAndDestroy( 2 ); |
|
5736 |
|
5737 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIPv6DNSTypeL") |
|
5738 return retval; |
|
5739 } |
|
5740 |
|
5741 |
|
5742 |
|
5743 |
|
5744 |
|
5745 //---------------------------------------------------------- |
|
5746 // CApSettingsDlg::GetIPv4DNSTypeL |
|
5747 //---------------------------------------------------------- |
|
5748 // |
|
5749 TInt CApSettingsDlg::GetIPv4DNSTypeL() |
|
5750 { |
|
5751 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetIPv4DNSTypeL") |
|
5752 |
|
5753 TInt retval( 0 ); |
|
5754 |
|
5755 HBufC* buf1 = HBufC::NewLC( KModifiableTextLength ); |
|
5756 TPtr16 ptr1( buf1->Des() ); |
|
5757 |
|
5758 HBufC* buf2 = HBufC::NewLC( KModifiableTextLength ); |
|
5759 TPtr16 ptr2( buf2->Des() ); |
|
5760 |
|
5761 // net type 4: if IspNameServ <> 0.0.0.0 => User defined |
|
5762 iApItem->ReadTextL( EApGprsIPNameServer1, ptr1 ); |
|
5763 iApItem->ReadTextL( EApGprsIPNameServer2, ptr2 ); |
|
5764 |
|
5765 if ( ( ptr1.Compare( KDynIpAddress ) == 0 ) |
|
5766 && ( ptr2.Compare( KDynIpAddress ) == 0 ) ) |
|
5767 { // dynamic, 0:0:... |
|
5768 retval = 0; |
|
5769 } |
|
5770 else |
|
5771 { // other value, user defined |
|
5772 retval = 2; |
|
5773 } |
|
5774 |
|
5775 CleanupStack::PopAndDestroy( 2 ); |
|
5776 |
|
5777 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetIPv4DNSTypeL") |
|
5778 return retval; |
|
5779 } |
|
5780 |
|
5781 |
|
5782 |
|
5783 |
|
5784 |
|
5785 // --------------------------------------------------------- |
|
5786 // CApSettingsDlg::StripNonNumberLC |
|
5787 // --------------------------------------------------------- |
|
5788 // |
|
5789 HBufC* CApSettingsDlg::StripNonNumberLC( const TDesC16& aInText ) |
|
5790 { |
|
5791 APSETUILOGGER_ENTERFN( ESettings,"Settings::StripNonNumberLC") |
|
5792 |
|
5793 // CLOG( ( EApItem, 0, _L( "-> CApSettingsDlg::StripNonNumberLC" ) ) ); |
|
5794 |
|
5795 TInt size = aInText.Length(); |
|
5796 HBufC* aOutText = HBufC::NewLC( size ); |
|
5797 TPtr ptr = aOutText->Des(); |
|
5798 |
|
5799 for ( TInt ii=0; ii<size; ++ii ) |
|
5800 { |
|
5801 // TText ch = aInText[ii]; |
|
5802 TChar ch = aInText[ii]; |
|
5803 if ( ch.IsDigit() ) |
|
5804 { |
|
5805 ptr.Append( ch ); |
|
5806 } |
|
5807 } |
|
5808 |
|
5809 APSETUILOGGER_LEAVEFN( ESettings,"Settings::StripNonNumberLC") |
|
5810 return aOutText; |
|
5811 } |
|
5812 |
|
5813 |
|
5814 //---------------------------------------------------------- |
|
5815 // CApSettingsDlg::BearerType2BearerItemPosL |
|
5816 //---------------------------------------------------------- |
|
5817 // |
|
5818 TInt CApSettingsDlg::BearerType2BearerItemPosL( TApBearerType aBearer ) |
|
5819 { |
|
5820 APSETUILOGGER_ENTERFN( ESettings,"Settings::BearerType2BearerItemPosL") |
|
5821 |
|
5822 TInt pos(0); |
|
5823 switch ( aBearer ) |
|
5824 { |
|
5825 case EApBearerTypeGPRS: |
|
5826 { |
|
5827 pos = KBearerListGprs; |
|
5828 break; |
|
5829 } |
|
5830 case EApBearerTypeWLAN: |
|
5831 { |
|
5832 if ( IsWlanSupported() ) |
|
5833 { |
|
5834 pos = KBearerListWLAN; |
|
5835 } |
|
5836 else |
|
5837 { |
|
5838 User::Leave( KErrNotSupported ); |
|
5839 } |
|
5840 break; |
|
5841 } |
|
5842 case EApBearerTypeCSD: |
|
5843 { |
|
5844 TBool isCsdSupported = |
|
5845 FeatureManager::FeatureSupported( KFeatureIdAppCsdSupport ); |
|
5846 if ( isCsdSupported ) |
|
5847 { |
|
5848 pos = KBearerListCSD; |
|
5849 if ( !IsWlanSupported() ) |
|
5850 { |
|
5851 pos--; |
|
5852 } |
|
5853 } |
|
5854 else |
|
5855 { // To be determined, what is correct |
|
5856 } |
|
5857 break; |
|
5858 } |
|
5859 case EApBearerTypeHSCSD: |
|
5860 { |
|
5861 if ( IsHSCSDEnabledL() ) |
|
5862 { |
|
5863 pos = KBearerListHSCSD; |
|
5864 if ( !IsWlanSupported() ) |
|
5865 { |
|
5866 pos--; |
|
5867 } |
|
5868 } |
|
5869 else |
|
5870 { // should not be possible, but be defensive, |
|
5871 // correct it to CSD, if possible... |
|
5872 TBool isCsdSupported = |
|
5873 FeatureManager::FeatureSupported( |
|
5874 KFeatureIdAppCsdSupport ); |
|
5875 if ( isCsdSupported ) |
|
5876 { |
|
5877 pos = KBearerListCSD; |
|
5878 if ( !IsWlanSupported() ) |
|
5879 { |
|
5880 pos--; |
|
5881 } |
|
5882 } |
|
5883 else |
|
5884 { // To be determined, what is correct |
|
5885 } |
|
5886 } |
|
5887 break; |
|
5888 } |
|
5889 default: |
|
5890 { |
|
5891 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
5892 User::Leave( KErrInvalidBearerType ); |
|
5893 break; |
|
5894 } |
|
5895 } |
|
5896 |
|
5897 APSETUILOGGER_LEAVEFN( ESettings,"Settings::BearerType2BearerItemPosL") |
|
5898 return pos; |
|
5899 } |
|
5900 |
|
5901 |
|
5902 //---------------------------------------------------------- |
|
5903 // CApSettingsDlg::BearerItemPos2BearerTypeL |
|
5904 //---------------------------------------------------------- |
|
5905 // |
|
5906 TApBearerType CApSettingsDlg::BearerItemPos2BearerTypeL( TInt aPos ) |
|
5907 { |
|
5908 APSETUILOGGER_ENTERFN( ESettings,"Settings::BearerItemPos2BearerTypeL") |
|
5909 |
|
5910 TApBearerType bearer; |
|
5911 CArrayFixFlat<TApBearerType>* bearerlist = |
|
5912 new(ELeave) CArrayFixFlat<TApBearerType>(4); |
|
5913 CleanupStack::PushL( bearerlist ); |
|
5914 |
|
5915 bearerlist->AppendL( EApBearerTypeGPRS ); |
|
5916 |
|
5917 if ( IsWlanSupported() ) |
|
5918 { |
|
5919 bearerlist->AppendL( EApBearerTypeWLAN ); |
|
5920 } |
|
5921 |
|
5922 TBool isCsdSupported = |
|
5923 FeatureManager::FeatureSupported( KFeatureIdAppCsdSupport ); |
|
5924 if ( isCsdSupported ) |
|
5925 { |
|
5926 bearerlist->AppendL( EApBearerTypeCSD ); |
|
5927 } |
|
5928 if ( IsHSCSDEnabledL() && isCsdSupported ) |
|
5929 { |
|
5930 bearerlist->AppendL( EApBearerTypeHSCSD ); |
|
5931 } |
|
5932 |
|
5933 __ASSERT_DEBUG( ( aPos < bearerlist->Count() ), \ |
|
5934 Panic( EInvalidBearerType ) ); |
|
5935 __ASSERT_DEBUG( ( aPos >= 0 ), Panic( EInvalidBearerType ) ); |
|
5936 |
|
5937 aPos = Max( aPos, 0 ); |
|
5938 aPos = Min( aPos, ( bearerlist->Count() - 1 ) ); |
|
5939 |
|
5940 bearer = bearerlist->At( aPos ); |
|
5941 |
|
5942 CleanupStack::PopAndDestroy( bearerlist ); |
|
5943 |
|
5944 APSETUILOGGER_LEAVEFN( ESettings,"Settings::BearerItemPos2BearerTypeL") |
|
5945 return bearer; |
|
5946 } |
|
5947 |
|
5948 |
|
5949 |
|
5950 //---------------------------------------------------------- |
|
5951 // CApSettingsDlg::ChangeWlanNetworkNameL |
|
5952 //---------------------------------------------------------- |
|
5953 // |
|
5954 void CApSettingsDlg::ChangeWlanNetworkNameL() |
|
5955 { |
|
5956 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWlanNetworkNameL") |
|
5957 |
|
5958 // Implement WLAN network name change |
|
5959 TInt currvalue( 0 ); |
|
5960 CDesCArrayFlat* items = FillPopupSettingPageLC( EApWlanNetworkName, |
|
5961 currvalue ); |
|
5962 |
|
5963 TInt attr_resid( 0 ); |
|
5964 GetResId( EApWlanNetworkName, attr_resid ); |
|
5965 HBufC* titlebuf; |
|
5966 CAknRadioButtonSettingPage* dlg; |
|
5967 if ( attr_resid ) |
|
5968 { |
|
5969 titlebuf = iEikonEnv->AllocReadResourceLC( attr_resid ); |
|
5970 dlg = new ( ELeave )CAknRadioButtonSettingPage( |
|
5971 R_RADIO_BUTTON_SETTING_PAGE, |
|
5972 currvalue, items ); |
|
5973 // must push 'cause SetSettingTextL can leave... |
|
5974 CleanupStack::PushL( dlg ); |
|
5975 TPtrC ptr( titlebuf->Des() ); |
|
5976 dlg->SetSettingTextL( ptr ); |
|
5977 CleanupStack::Pop(); // dlg |
|
5978 } |
|
5979 else |
|
5980 { |
|
5981 dlg = new ( ELeave )CAknRadioButtonSettingPage( |
|
5982 R_RADIO_BUTTON_SETTING_PAGE, currvalue, items ); |
|
5983 } |
|
5984 if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenAccepted ) ) |
|
5985 { |
|
5986 if ( !currvalue ) |
|
5987 {// user defined |
|
5988 QueryWlanNetworkNameL(); |
|
5989 } |
|
5990 else |
|
5991 { // scan for, select one! |
|
5992 CConnectionUiUtilities* connUiUtils = |
|
5993 CConnectionUiUtilities::NewL(); |
|
5994 CleanupStack::PushL( connUiUtils ); |
|
5995 |
|
5996 TWlanSsid ssid; |
|
5997 TWlanConnectionMode connmode; |
|
5998 TWlanConnectionSecurityMode secmode; |
|
5999 TBool ret = connUiUtils->SearchWLANNetwork( ssid, |
|
6000 connmode, |
|
6001 secmode ); |
|
6002 if ( ret ) |
|
6003 { |
|
6004 HBufC* tmp = HBufC::NewLC( KCommsDbSvrMaxFieldLength ); |
|
6005 TPtr16 tmpPtr16 = tmp->Des(); |
|
6006 CnvUtfConverter::ConvertToUnicodeFromUtf8( tmpPtr16, ssid); |
|
6007 |
|
6008 iApItem->WriteTextL( EApWlanNetworkName, *tmp ); |
|
6009 CleanupStack::PopAndDestroy( tmp ); |
|
6010 // now handle connmode & secmode settings |
|
6011 if ( connmode == EWlanConnectionModeInfrastructure ) |
|
6012 { |
|
6013 iApItem->WriteUint( EApWlanNetworkMode, EInfra ); |
|
6014 } |
|
6015 else |
|
6016 { |
|
6017 if ( connmode == EWlanConnectionModeAdhoc ) |
|
6018 { |
|
6019 iApItem->WriteUint( EApWlanNetworkMode, EAdhoc ); |
|
6020 } |
|
6021 else |
|
6022 { |
|
6023 User::Leave( KErrNotSupported ); |
|
6024 } |
|
6025 } |
|
6026 switch (secmode) |
|
6027 { |
|
6028 case EWlanConnectionSecurityOpen: |
|
6029 { |
|
6030 iApItem->WriteUint( EApWlanSecurityMode, EOpen ); |
|
6031 break; |
|
6032 } |
|
6033 case EWlanConnectionSecurityWep: |
|
6034 { |
|
6035 iApItem->WriteUint( EApWlanSecurityMode, EWep ); |
|
6036 break; |
|
6037 } |
|
6038 case EWlanConnectionSecurity802d1x: |
|
6039 { |
|
6040 iApItem->WriteUint( EApWlanSecurityMode, E802_1x ); |
|
6041 break; |
|
6042 } |
|
6043 case EWlanConnectionSecurityWpa: |
|
6044 { |
|
6045 iApItem->WriteUint( EApWlanSecurityMode, EWpa ); |
|
6046 break; |
|
6047 } |
|
6048 case EWlanConnectionSecurityWpaPsk: |
|
6049 { |
|
6050 iApItem->WriteUint( EApWlanSecurityMode, EWpa ); |
|
6051 break; |
|
6052 } |
|
6053 default: |
|
6054 { |
|
6055 break; |
|
6056 } |
|
6057 } |
|
6058 |
|
6059 } |
|
6060 CleanupStack::PopAndDestroy( connUiUtils ); |
|
6061 } |
|
6062 } |
|
6063 if ( attr_resid ) |
|
6064 { |
|
6065 // titlebuf, text title readed from resource... |
|
6066 CleanupStack::PopAndDestroy(); |
|
6067 } |
|
6068 // items, will also delete all elements in the array! |
|
6069 CleanupStack::PopAndDestroy( items ); |
|
6070 |
|
6071 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeWlanNetworkNameL") |
|
6072 } |
|
6073 |
|
6074 |
|
6075 //---------------------------------------------------------- |
|
6076 // CApSettingsDlg::ChangeWlanSecuritySettings |
|
6077 //---------------------------------------------------------- |
|
6078 // |
|
6079 TInt CApSettingsDlg::ChangeWlanSecuritySettingsL() |
|
6080 { |
|
6081 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWlanSecuritySettingsL") |
|
6082 |
|
6083 TInt retval(0); |
|
6084 TUint32 secmode( 0 ); |
|
6085 iApItem->ReadUint( EApWlanSecurityMode, secmode ); |
|
6086 |
|
6087 TBool need2changeid( EFalse ); |
|
6088 TUint32 origServiceId(0); |
|
6089 iApItem->ReadUint( EApIapServiceId, origServiceId ); |
|
6090 if ( iOriginalBearerType != iApItem->BearerTypeL() ) |
|
6091 { |
|
6092 need2changeid = ETrue; |
|
6093 iApItem->WriteUint( EApIapServiceId, 0 ); |
|
6094 } |
|
6095 |
|
6096 switch ( secmode ) |
|
6097 { |
|
6098 case EOpen: |
|
6099 { |
|
6100 ShowNoteL( R_APUI_VIEW_NO_SECURITY_SETTINGS ); |
|
6101 break; |
|
6102 } |
|
6103 case EWep: |
|
6104 { |
|
6105 retval = ChangeWepSecuritySettingsL(); |
|
6106 break; |
|
6107 } |
|
6108 case E802_1x: |
|
6109 { |
|
6110 retval = Change8021xSecuritySettingsL(); |
|
6111 break; |
|
6112 } |
|
6113 case EWpa: |
|
6114 case EWpa2: |
|
6115 { |
|
6116 retval = ChangeWpaSecuritySettingsL(); |
|
6117 break; |
|
6118 } |
|
6119 default: |
|
6120 { |
|
6121 // some weird error, repair it... |
|
6122 __ASSERT_DEBUG( EFalse, Panic( EInvalidBearerType ) ); |
|
6123 break; |
|
6124 } |
|
6125 } |
|
6126 if ( need2changeid ) |
|
6127 { |
|
6128 iApItem->WriteUint( EApIapServiceId, origServiceId ); |
|
6129 } |
|
6130 |
|
6131 APSETUILOGGER_LEAVEFN( ESettings,"Settings::ChangeWlanSecuritySettingsL") |
|
6132 return retval; |
|
6133 } |
|
6134 |
|
6135 |
|
6136 //---------------------------------------------------------- |
|
6137 // CApSettingsDlg::ChangeWepSecuritySettingsL |
|
6138 //---------------------------------------------------------- |
|
6139 // |
|
6140 TInt CApSettingsDlg::ChangeWepSecuritySettingsL() |
|
6141 { |
|
6142 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWepSecuritySettingsL<->") |
|
6143 |
|
6144 return iHandler->iModel->ChangeWepSettingsL( iApItem ); |
|
6145 } |
|
6146 |
|
6147 |
|
6148 |
|
6149 //---------------------------------------------------------- |
|
6150 // CApSettingsDlg::ChangeWpaSecuritySettingsL |
|
6151 //---------------------------------------------------------- |
|
6152 // |
|
6153 TInt CApSettingsDlg::ChangeWpaSecuritySettingsL() |
|
6154 { |
|
6155 APSETUILOGGER_ENTERFN( ESettings,"Settings::ChangeWpaSecuritySettingsL<->") |
|
6156 |
|
6157 return iHandler->iModel->ChangeWpaSettingsL( iApItem ); |
|
6158 } |
|
6159 |
|
6160 |
|
6161 //---------------------------------------------------------- |
|
6162 // CApSettingsDlg::Change8021xSecuritySettingsL |
|
6163 //---------------------------------------------------------- |
|
6164 // |
|
6165 TInt CApSettingsDlg::Change8021xSecuritySettingsL() |
|
6166 { |
|
6167 APSETUILOGGER_ENTERFN( ESettings,"Settings::Change8021xSecuritySettingsL<->") |
|
6168 |
|
6169 return iHandler->iModel->Change8021xSettingsL( iApItem ); |
|
6170 } |
|
6171 |
|
6172 |
|
6173 |
|
6174 |
|
6175 //---------------------------------------------------------- |
|
6176 // CApSettingsDlg::IsWlanSupported |
|
6177 //---------------------------------------------------------- |
|
6178 // |
|
6179 TBool CApSettingsDlg::IsWlanSupported() |
|
6180 { |
|
6181 APSETUILOGGER_ENTERFN( ESettings,"Settings::IsWlanSupported") |
|
6182 |
|
6183 TBool retval = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ); |
|
6184 #ifdef __TEST_WLAN_SUPPORT |
|
6185 retval = ETrue; |
|
6186 #endif // __TEST_WLAN_SUPPORT |
|
6187 |
|
6188 APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsWlanSupported") |
|
6189 return retval; |
|
6190 } |
|
6191 |
|
6192 |
|
6193 |
|
6194 //---------------------------------------------------------- |
|
6195 // CApSettingsDlg::QueryWlanNetworkNameL |
|
6196 //---------------------------------------------------------- |
|
6197 // |
|
6198 TBool CApSettingsDlg::QueryWlanNetworkNameL() |
|
6199 { |
|
6200 APSETUILOGGER_ENTERFN( ESettings,"Settings::QueryWlanNetworkNameL") |
|
6201 |
|
6202 TBool retval( EFalse ); |
|
6203 |
|
6204 HBufC* buff = HBufC::NewLC( KModifiableTextLength ); |
|
6205 TPtr16 ptr( buff->Des() ); |
|
6206 iApItem->ReadTextL( EApWlanNetworkName, ptr ); |
|
6207 |
|
6208 CAknQueryDialog* dlg = |
|
6209 CAknQueryDialog::NewL( ptr, CAknQueryDialog::ENoTone ); |
|
6210 |
|
6211 if ( dlg->ExecuteLD( R_APUI_WLAN_NAME_QUERY ) ) |
|
6212 { |
|
6213 iApItem->WriteTextL( EApWlanNetworkName, ptr ); |
|
6214 retval = ETrue; |
|
6215 } |
|
6216 CleanupStack::PopAndDestroy( buff ); |
|
6217 |
|
6218 APSETUILOGGER_LEAVEFN( ESettings,"Settings::QueryWlanNetworkNameL") |
|
6219 return retval; |
|
6220 } |
|
6221 |
|
6222 |
|
6223 //---------------------------------------------------------- |
|
6224 // CApSettingsDlg::IsNetMaskAndGatewayVisible |
|
6225 //---------------------------------------------------------- |
|
6226 // |
|
6227 TBool CApSettingsDlg::IsNetMaskAndGatewayVisibleL() |
|
6228 { |
|
6229 APSETUILOGGER_ENTERFN( ESettings,"Settings::IsNetMaskAndGatewayVisibleL") |
|
6230 |
|
6231 TBool retval(EFalse); |
|
6232 // display only if: |
|
6233 // Phone IP Addr. <> Automatic (0.0.0.0) |
|
6234 HBufC* tmpValue = HBufC::NewLC( KModifiableTextLength ); |
|
6235 TPtr ptr( tmpValue->Des() ); |
|
6236 iApItem->ReadTextL( EApIspIPAddr, ptr ); |
|
6237 if ( ( tmpValue->Compare( KDynIpAddress ) != 0 ) |
|
6238 && ( tmpValue->Compare( KEmptyText ) != 0 ) ) |
|
6239 { |
|
6240 retval = ETrue; |
|
6241 } |
|
6242 CleanupStack::PopAndDestroy( tmpValue ); |
|
6243 |
|
6244 APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsNetMaskAndGatewayVisibleL") |
|
6245 return retval; |
|
6246 } |
|
6247 |
|
6248 |
|
6249 |
|
6250 //---------------------------------------------------------- |
|
6251 // CApSettingsDlg::GetAdHocChannelL |
|
6252 //---------------------------------------------------------- |
|
6253 // |
|
6254 TUint32 CApSettingsDlg::GetAdHocChannelL() |
|
6255 { |
|
6256 APSETUILOGGER_ENTERFN( ESettings,"Settings::GetAdHocChannelL") |
|
6257 |
|
6258 // Get real ad-hoc channel |
|
6259 // Default: KDefAdhocChannel |
|
6260 TInt channel( KDefAdhocChannel ); |
|
6261 TUint32 retval(0); |
|
6262 iApItem->ReadUint( EApWlanChannelId, retval ); |
|
6263 channel = TInt(retval); |
|
6264 if ( !channel ) |
|
6265 { |
|
6266 channel = KDefAdhocChannel; |
|
6267 } |
|
6268 |
|
6269 CAknNumberQueryDialog* dlg = |
|
6270 CAknNumberQueryDialog::NewL( channel, CAknQueryDialog::ENoTone ); |
|
6271 |
|
6272 if ( dlg->ExecuteLD( R_APUI_WLAN_ADHOC_CHANNEL_QUERY ) ) |
|
6273 { |
|
6274 retval = channel; |
|
6275 } |
|
6276 |
|
6277 APSETUILOGGER_LEAVEFN( ESettings,"Settings::GetAdHocChannelL") |
|
6278 return retval; |
|
6279 } |
|
6280 |
|
6281 |
|
6282 |
|
6283 //---------------------------------------------------------- |
|
6284 // CApSettingsDlg::IsAdhocChannelVisible |
|
6285 //---------------------------------------------------------- |
|
6286 // |
|
6287 TBool CApSettingsDlg::IsAdhocChannelVisible() |
|
6288 { |
|
6289 APSETUILOGGER_ENTERFN( ESettings,"Settings::IsAdhocChannelVisible") |
|
6290 |
|
6291 TBool retval(EFalse); |
|
6292 TUint32 netmode( 0 ); |
|
6293 iApItem->ReadUint( EApWlanNetworkMode, netmode ); |
|
6294 if ( netmode == EAdhoc ) |
|
6295 { |
|
6296 retval = ETrue; |
|
6297 } |
|
6298 |
|
6299 APSETUILOGGER_LEAVEFN( ESettings,"Settings::IsAdhocChannelVisible") |
|
6300 return retval; |
|
6301 } |
|
6302 |
|
6303 |
|
6304 |
|
6305 //---------------------------------------------------------- |
|
6306 // CApSettingsDlg::HasSecuritySettingsFilledL |
|
6307 //---------------------------------------------------------- |
|
6308 // |
|
6309 TBool CApSettingsDlg::HasSecuritySettingsFilledL() |
|
6310 { |
|
6311 APSETUILOGGER_ENTERFN( ESettings,"Settings::HasSecuritySettingsFilledL<->") |
|
6312 |
|
6313 return iDataModel->HasWlanSecSettingsFilledL( *iApItem ); |
|
6314 } |
|
6315 |
|
6316 |
|
6317 |
|
6318 //---------------------------------------------------------- |
|
6319 // CApSettingsDlg::LimitSecMode |
|
6320 //---------------------------------------------------------- |
|
6321 // |
|
6322 void CApSettingsDlg::LimitSecMode() |
|
6323 { |
|
6324 APSETUILOGGER_ENTERFN( ESettings,"Settings::LimitSecMode") |
|
6325 |
|
6326 TUint32 secmode( 0 ); |
|
6327 iApItem->ReadUint( EApWlanSecurityMode, secmode ); |
|
6328 switch ( secmode ) |
|
6329 { |
|
6330 case EOpen: |
|
6331 case EWep: |
|
6332 // nothing to do in this case |
|
6333 { |
|
6334 break; |
|
6335 } |
|
6336 case E802_1x: |
|
6337 case EWpa: |
|
6338 case EWpa2: |
|
6339 default: |
|
6340 { |
|
6341 iApItem->WriteUint( EApWlanSecurityMode, EOpen ); |
|
6342 break; |
|
6343 } |
|
6344 } |
|
6345 |
|
6346 APSETUILOGGER_LEAVEFN( ESettings,"Settings::LimitSecMode") |
|
6347 } |
|
6348 |
|
6349 |
|
6350 |
|
6351 |
|
6352 // --------------------------------------------------------- |
|
6353 // CApSettingsDlg::CanSaveWlanCompulsoriesL( ) |
|
6354 // --------------------------------------------------------- |
|
6355 // |
|
6356 CApSettingsDlg::TSaveAction CApSettingsDlg::CanSaveWlanCompulsoriesL( |
|
6357 TApMember& aDataNeeded ) |
|
6358 { |
|
6359 TSaveAction retval( EApCanSave ); |
|
6360 |
|
6361 HBufC *sgd = HBufC::NewLC( KModifiableTextLength ); |
|
6362 TPtr16 ptr( sgd->Des() ); |
|
6363 |
|
6364 if ( (retval != EApShallGoBack) && (retval != EApMustDelete) |
|
6365 && IsNetMaskAndGatewayVisibleL() ) |
|
6366 { // now check compulsory fields |
|
6367 iApItem->ReadTextL( EApWlanIpNetMask, ptr ); |
|
6368 if ( ( ptr.Compare( KDynIpAddress ) == 0 ) |
|
6369 || ( ptr.Compare( KEmptyText ) == 0 ) ) |
|
6370 { |
|
6371 retval = EApShallGoBack; |
|
6372 aDataNeeded = EApWlanIpNetMask; |
|
6373 if ( AskQueryL( |
|
6374 R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) ) |
|
6375 { |
|
6376 retval = EApMustDelete; |
|
6377 } |
|
6378 } |
|
6379 else |
|
6380 { |
|
6381 iApItem->ReadTextL( EApIspIPGateway, ptr ); |
|
6382 if ( ( sgd->Compare( KDynIpAddress ) == 0 ) |
|
6383 || ( sgd->Compare( KEmptyText ) == 0 ) ) |
|
6384 { |
|
6385 retval = EApShallGoBack; |
|
6386 aDataNeeded = EApIspIPGateway; |
|
6387 if ( AskQueryL( |
|
6388 R_APUI_VIEW_NETW_QUEST_IAP_INCOMPLETE_DELETE ) |
|
6389 ) |
|
6390 { |
|
6391 retval = EApMustDelete; |
|
6392 } |
|
6393 } |
|
6394 } |
|
6395 } |
|
6396 CleanupStack::PopAndDestroy( sgd ); // sgd |
|
6397 |
|
6398 return retval; |
|
6399 } |
|
6400 |
|
6401 |
|
6402 // --------------------------------------------------------- |
|
6403 // CApSettingsDlg::RestoreIpv4SettingsL() |
|
6404 // --------------------------------------------------------- |
|
6405 // |
|
6406 void CApSettingsDlg::RestoreIpv4SettingsL() |
|
6407 { |
|
6408 HBufC* buf = HBufC::NewLC( KModifiableTextLength ); |
|
6409 TPtr ptr( buf->Des() ); |
|
6410 |
|
6411 iBackupApItem->ReadTextL( EApIspIPAddr, ptr ); |
|
6412 iApItem->WriteTextL( EApIspIPAddr, ptr ); |
|
6413 |
|
6414 iBackupApItem->ReadTextL( EApIspIPNetMask, ptr ); |
|
6415 iApItem->WriteTextL( EApIspIPNetMask, ptr ); |
|
6416 |
|
6417 iBackupApItem->ReadTextL( EApIspIPGateway, ptr ); |
|
6418 iApItem->WriteTextL( EApIspIPGateway, ptr ); |
|
6419 |
|
6420 iBackupApItem->ReadTextL( EApIspIPNameServer1, ptr ); |
|
6421 iApItem->WriteTextL( EApIspIPNameServer1, ptr ); |
|
6422 |
|
6423 iBackupApItem->ReadTextL( EApIspIPNameServer2, ptr ); |
|
6424 iApItem->WriteTextL( EApIspIPNameServer2, ptr ); |
|
6425 |
|
6426 CleanupStack::PopAndDestroy( buf ); |
|
6427 |
|
6428 } |
|
6429 |
|
6430 |
|
6431 |
|
6432 // End of File |