49 // CVpnApItem::NewLC |
49 // CVpnApItem::NewLC |
50 // --------------------------------------------------------- |
50 // --------------------------------------------------------- |
51 // |
51 // |
52 EXPORT_C CVpnApItem* CVpnApItem::NewLC() |
52 EXPORT_C CVpnApItem* CVpnApItem::NewLC() |
53 { |
53 { |
54 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::NewL" ) ) ); |
54 return NULL; |
55 |
|
56 CVpnApItem* self = new ( ELeave ) CVpnApItem; |
|
57 CleanupStack::PushL( self ); |
|
58 self->ConstructL(); |
|
59 |
|
60 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::NewL" ) ) ); |
|
61 |
|
62 return self; |
|
63 } |
55 } |
64 |
56 |
65 |
57 |
66 // --------------------------------------------------------- |
58 // --------------------------------------------------------- |
67 // CVpnApItem::~CVpnApItem |
59 // CVpnApItem::~CVpnApItem |
68 // --------------------------------------------------------- |
60 // --------------------------------------------------------- |
69 // |
61 // |
70 EXPORT_C CVpnApItem::~CVpnApItem() |
62 EXPORT_C CVpnApItem::~CVpnApItem() |
71 { |
63 { |
72 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::~CVpnApItem" ) ) ); |
|
73 |
|
74 delete iName; |
|
75 delete iPolicy; |
|
76 delete iProxyServerAddress; |
|
77 delete iRealIapName; |
|
78 delete iPolicyId; |
|
79 delete iVpnIapNetworkName; |
|
80 |
|
81 } |
64 } |
82 |
65 |
83 |
66 |
84 // --------------------------------------------------------- |
67 // --------------------------------------------------------- |
85 // CVpnApItem::ConstructL |
68 // CVpnApItem::ConstructL |
86 // --------------------------------------------------------- |
69 // --------------------------------------------------------- |
87 // |
70 // |
88 EXPORT_C void CVpnApItem::ConstructL() |
71 EXPORT_C void CVpnApItem::ConstructL() |
89 { |
72 { |
90 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ConstructL" ) ) ); |
|
91 |
|
92 // as we are in ConstructL called from NewLC, |
|
93 // 'this' is already on the CleanupStack, |
|
94 // so do not push members onto it! |
|
95 iName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
96 iPolicy = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
97 iProxyServerAddress = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
98 iRealIapName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
99 iPolicyId = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
100 iVpnIapNetworkName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
101 |
|
102 RFs fs; |
|
103 CleanupClosePushL<RFs>( fs ); |
|
104 User::LeaveIfError( fs.Connect() ); |
|
105 |
|
106 // can't use resource here because it is not added yet.... |
|
107 TFileName resourceFile; |
|
108 resourceFile.Append( KApEngineResDriveZ ); |
|
109 resourceFile.Append( KDC_RESOURCE_FILES_DIR ); |
|
110 resourceFile.Append( KApEngineResFileName ); |
|
111 BaflUtils::NearestLanguageFile( fs, resourceFile ); |
|
112 |
|
113 RResourceFile rf; |
|
114 CleanupClosePushL<RResourceFile>( rf ); |
|
115 rf.OpenL( fs, resourceFile ); |
|
116 rf.ConfirmSignatureL( 0 ); |
|
117 HBufC8* readBuffer = rf.AllocReadLC( R_APNG_DEFAULT_VPN_AP_NAME ); |
|
118 // as we are expecting HBufC16... |
|
119 __ASSERT_DEBUG( ( readBuffer->Length()%2 ) == 0, |
|
120 ApCommons::Panic( EWrongResourceFormat ) ); |
|
121 const TPtrC16 ptrReadBuffer( (TText16*) readBuffer->Ptr(), |
|
122 ( readBuffer->Length() + 1 ) >> 1 ); |
|
123 HBufC16* textBuffer=HBufC16::NewL( ptrReadBuffer.Length() ); |
|
124 *textBuffer=ptrReadBuffer; |
|
125 CleanupStack::PopAndDestroy( readBuffer ); // readbuffer |
|
126 CleanupStack::PushL( textBuffer ); |
|
127 |
|
128 WriteTextL( EApVpnWapAccessPointName, *textBuffer ); |
|
129 |
|
130 WriteUint( EApVpnProxyPortNumber, KVpnDefProxyPortNumber ); |
|
131 |
|
132 CleanupStack::PopAndDestroy( 3 ); // textbuffer, fs, rf |
|
133 |
|
134 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::ConstructL" ) ) ); |
|
135 |
|
136 } |
73 } |
137 |
74 |
138 |
75 |
139 // --------------------------------------------------------- |
76 // --------------------------------------------------------- |
140 // CVpnApItem::CVpnApItem |
77 // CVpnApItem::CVpnApItem |
141 // --------------------------------------------------------- |
78 // --------------------------------------------------------- |
142 // |
79 // |
143 EXPORT_C CVpnApItem::CVpnApItem() |
80 EXPORT_C CVpnApItem::CVpnApItem() |
144 { |
81 { |
145 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::CVpnApItem" ) ) ); |
|
146 } |
82 } |
147 |
83 |
148 |
84 |
149 |
85 |
150 // --------------------------------------------------------- |
86 // --------------------------------------------------------- |
151 // CVpnApItem::CopyFromL |
87 // CVpnApItem::CopyFromL |
152 // --------------------------------------------------------- |
88 // --------------------------------------------------------- |
153 // |
89 // |
154 EXPORT_C void CVpnApItem::CopyFromL( const CVpnApItem& aCopyFrom ) |
90 EXPORT_C void CVpnApItem::CopyFromL( const CVpnApItem& aCopyFrom ) |
155 { |
91 { |
156 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::CopyFromL" ) ) ); |
|
157 |
|
158 iVpnTableId = aCopyFrom.iVpnTableId; |
|
159 iVpnIapId = aCopyFrom.iVpnIapId; |
|
160 iRealIapId = aCopyFrom.iRealIapId; |
|
161 iVpnRealWapId = aCopyFrom.iVpnRealWapId; |
|
162 iVirtualBearerID = aCopyFrom.iVirtualBearerID; |
|
163 iProxyPort = aCopyFrom.iProxyPort; |
|
164 iHomeNetwork = aCopyFrom.iHomeNetwork; |
|
165 |
|
166 WriteTextL( EApVpnWapAccessPointName, *aCopyFrom.iName ); |
|
167 WriteTextL( EApVpnPolicy, *aCopyFrom.iPolicy ); |
|
168 WriteLongTextL( EApVpnProxyServerAddress, *aCopyFrom.iProxyServerAddress ); |
|
169 WriteTextL( EApVpnRealIapName, *aCopyFrom.iRealIapName ); |
|
170 WriteTextL( EApVpnPolicyId, *aCopyFrom.iPolicyId ); |
|
171 WriteTextL( EApVpnIapNetworkName, *aCopyFrom.iVpnIapNetworkName ); |
|
172 |
|
173 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::CopyFromL" ) ) ); |
|
174 } |
92 } |
175 |
93 |
176 |
94 |
177 |
95 |
178 |
96 |
180 // CVpnApItem::operator== |
98 // CVpnApItem::operator== |
181 // --------------------------------------------------------- |
99 // --------------------------------------------------------- |
182 // |
100 // |
183 EXPORT_C TBool CVpnApItem::operator==( const CVpnApItem& aItem ) const |
101 EXPORT_C TBool CVpnApItem::operator==( const CVpnApItem& aItem ) const |
184 { |
102 { |
185 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator==" ) ) ); |
103 return EFalse; |
186 |
|
187 TBool retval( EFalse ); |
|
188 |
|
189 if ( ( iVpnTableId == aItem.iVpnTableId ) && |
|
190 ( iVpnIapId == aItem.iVpnIapId ) && |
|
191 ( iRealIapId == aItem.iRealIapId ) && |
|
192 ( iVpnRealWapId == aItem.iVpnRealWapId ) && |
|
193 ( iVirtualBearerID == aItem.iVirtualBearerID ) && |
|
194 ( iProxyPort == aItem.iProxyPort ) && |
|
195 ( iHomeNetwork == aItem.iHomeNetwork ) |
|
196 ) |
|
197 { |
|
198 if ( |
|
199 ( iName->Compare( *aItem.iName ) == 0 ) |
|
200 && ( iPolicy->Compare( *aItem.iPolicy ) == 0 ) |
|
201 && ( iProxyServerAddress->Compare( |
|
202 *aItem.iProxyServerAddress ) == 0 ) |
|
203 && ( iRealIapName->Compare( *aItem.iRealIapName ) == 0 ) |
|
204 && ( iPolicyId->Compare( *aItem.iPolicyId ) == 0 ) |
|
205 && ( iVpnIapNetworkName->Compare( |
|
206 *aItem.iVpnIapNetworkName ) == 0 ) |
|
207 ) |
|
208 { |
|
209 retval = ETrue; |
|
210 } |
|
211 } |
|
212 |
|
213 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::operator==" ) ) ); |
|
214 |
|
215 return ( retval ); |
|
216 } |
104 } |
217 |
105 |
218 |
106 |
219 // --------------------------------------------------------- |
107 // --------------------------------------------------------- |
220 // CVpnApItem::operator!= |
108 // CVpnApItem::operator!= |
221 // --------------------------------------------------------- |
109 // --------------------------------------------------------- |
222 // |
110 // |
223 EXPORT_C TBool CVpnApItem::operator!=( const CVpnApItem& aItem ) const |
111 EXPORT_C TBool CVpnApItem::operator!=( const CVpnApItem& aItem ) const |
224 { |
112 { |
225 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator!=" ) ) ); |
113 return EFalse; |
226 |
|
227 TBool ret = ( *this == aItem ); |
|
228 |
|
229 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::operator!=" ) ) ); |
|
230 return ( !ret ); |
|
231 } |
114 } |
232 |
115 |
233 |
116 |
234 |
117 |
235 // --------------------------------------------------------- |
118 // --------------------------------------------------------- |
237 // --------------------------------------------------------- |
120 // --------------------------------------------------------- |
238 // |
121 // |
239 EXPORT_C void CVpnApItem::ReadTextL( const TVpnApMember aColumn, |
122 EXPORT_C void CVpnApItem::ReadTextL( const TVpnApMember aColumn, |
240 TDes16& aValue ) |
123 TDes16& aValue ) |
241 { |
124 { |
242 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadTextL" ) ) ); |
|
243 |
|
244 switch ( aColumn ) |
|
245 { |
|
246 case EApVpnWapAccessPointName: |
|
247 { |
|
248 aValue.SetLength( iName->Length() ); |
|
249 aValue.Format( KFormat, iName ); |
|
250 break; |
|
251 } |
|
252 case EApVpnProxyServerAddress: |
|
253 { |
|
254 // make it large enough to hold |
|
255 aValue.SetLength( iProxyServerAddress->Length() ); |
|
256 aValue.Format( KFormat, iProxyServerAddress ); |
|
257 break; |
|
258 } |
|
259 case EApVpnPolicy: |
|
260 { |
|
261 aValue.SetLength( iPolicy->Length() ); |
|
262 aValue.Format( KFormat, iPolicy ); |
|
263 break; |
|
264 } |
|
265 case EApVpnRealIapName: |
|
266 { |
|
267 aValue.SetLength( iRealIapName->Length() ); |
|
268 aValue.Format( KFormat, iRealIapName ); |
|
269 break; |
|
270 } |
|
271 case EApVpnPolicyId: |
|
272 { |
|
273 aValue.SetLength( iPolicyId->Length() ); |
|
274 aValue.Format( KFormat, iPolicyId ); |
|
275 break; |
|
276 } |
|
277 case EApVpnIapNetworkName: |
|
278 { |
|
279 aValue.SetLength( iVpnIapNetworkName->Length() ); |
|
280 aValue.Format( KFormat, iVpnIapNetworkName ); |
|
281 break; |
|
282 } |
|
283 default: |
|
284 { |
|
285 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
286 User::Leave( KErrInvalidColumn ); |
|
287 } |
|
288 } |
|
289 |
|
290 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadTextL" ) ) ); |
|
291 } |
125 } |
292 |
126 |
293 |
127 |
294 |
128 |
295 // --------------------------------------------------------- |
129 // --------------------------------------------------------- |
298 // |
132 // |
299 EXPORT_C const HBufC* CVpnApItem::ReadConstLongTextL( |
133 EXPORT_C const HBufC* CVpnApItem::ReadConstLongTextL( |
300 const TVpnApMember aColumn |
134 const TVpnApMember aColumn |
301 ) |
135 ) |
302 { |
136 { |
303 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadConstLongTextL" ) ) ); |
137 return NULL; |
304 |
|
305 HBufC* retval = NULL; |
|
306 switch ( aColumn ) |
|
307 { |
|
308 case EApVpnProxyServerAddress: |
|
309 { |
|
310 retval = iProxyServerAddress; |
|
311 break; |
|
312 } |
|
313 default: |
|
314 { |
|
315 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
316 User::Leave( KErrInvalidColumn ); |
|
317 break; |
|
318 } |
|
319 } |
|
320 |
|
321 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadConstLongTextL" ) ) ); |
|
322 return retval; |
|
323 } |
138 } |
324 |
139 |
325 |
140 |
326 // --------------------------------------------------------- |
141 // --------------------------------------------------------- |
327 // CVpnApItem::ReadUint |
142 // CVpnApItem::ReadUint |
328 // --------------------------------------------------------- |
143 // --------------------------------------------------------- |
329 // |
144 // |
330 EXPORT_C TInt CVpnApItem::ReadUint( const TVpnApMember aColumn, |
145 EXPORT_C TInt CVpnApItem::ReadUint( const TVpnApMember aColumn, |
331 TUint32& aValue ) |
146 TUint32& aValue ) |
332 { |
147 { |
333 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadUint" ) ) ); |
148 return KErrNotSupported; |
334 |
|
335 TInt retval ( KErrNone ); |
|
336 switch ( aColumn ) |
|
337 { |
|
338 case EApVpnWapAccessPointID: |
|
339 { |
|
340 aValue = iVpnWapId; |
|
341 break; |
|
342 } |
|
343 case EApVpnIapID: |
|
344 { |
|
345 aValue = iVpnIapId; |
|
346 break; |
|
347 } |
|
348 case EApVpnRealIapID: |
|
349 { |
|
350 aValue = iRealIapId; |
|
351 break; |
|
352 } |
|
353 case EApVpnRealWapID: |
|
354 { |
|
355 aValue = iVpnRealWapId; |
|
356 break; |
|
357 } |
|
358 case EApVpnProxyPortNumber: |
|
359 { |
|
360 aValue = iProxyPort; |
|
361 break; |
|
362 } |
|
363 case EApVpnHomeNetworkID: |
|
364 { |
|
365 aValue = iHomeNetwork; |
|
366 break; |
|
367 } |
|
368 case EApVpnIapNetworkID: |
|
369 { |
|
370 aValue = iVpnIapNetwork; |
|
371 break; |
|
372 } |
|
373 default : |
|
374 { |
|
375 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
376 retval = KErrInvalidColumn; |
|
377 break; |
|
378 } |
|
379 } |
|
380 |
|
381 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadUint" ) ) ); |
|
382 return retval; |
|
383 } |
149 } |
384 |
150 |
385 |
151 |
386 |
152 |
387 // --------------------------------------------------------- |
153 // --------------------------------------------------------- |
412 // --------------------------------------------------------- |
168 // --------------------------------------------------------- |
413 // |
169 // |
414 EXPORT_C TInt CVpnApItem::WriteTextL( const TVpnApMember aColumn, |
170 EXPORT_C TInt CVpnApItem::WriteTextL( const TVpnApMember aColumn, |
415 const TDesC16& aValue ) |
171 const TDesC16& aValue ) |
416 { |
172 { |
417 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteTextL" ) ) ); |
173 return KErrNotSupported; |
418 |
|
419 TInt retval( KErrNone ); |
|
420 switch ( aColumn ) |
|
421 { |
|
422 case EApVpnWapAccessPointName: |
|
423 { |
|
424 HBufC* sgd = aValue.AllocLC(); |
|
425 sgd->Des().Trim(); |
|
426 ReAllocL( iName, *sgd); |
|
427 CleanupStack::PopAndDestroy( sgd ); // sgd |
|
428 break; |
|
429 } |
|
430 case EApVpnPolicy: |
|
431 { |
|
432 ReAllocL( iPolicy, aValue); |
|
433 break; |
|
434 } |
|
435 case EApVpnProxyServerAddress: |
|
436 { |
|
437 ReAllocL( iProxyServerAddress, aValue); |
|
438 break; |
|
439 } |
|
440 case EApVpnRealIapName: |
|
441 { |
|
442 ReAllocL( iRealIapName, aValue ); |
|
443 break; |
|
444 } |
|
445 case EApVpnPolicyId: |
|
446 { |
|
447 ReAllocL( iPolicyId, aValue ); |
|
448 break; |
|
449 } |
|
450 case EApVpnIapNetworkName: |
|
451 { |
|
452 ReAllocL( iVpnIapNetworkName, aValue ); |
|
453 break; |
|
454 } |
|
455 default: |
|
456 { |
|
457 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
458 retval = KErrInvalidColumn; |
|
459 break; |
|
460 } |
|
461 } |
|
462 |
|
463 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteTextL" ) ) ); |
|
464 return retval; |
|
465 } |
174 } |
466 |
175 |
467 |
176 |
468 |
177 |
469 // --------------------------------------------------------- |
178 // --------------------------------------------------------- |
503 // --------------------------------------------------------- |
192 // --------------------------------------------------------- |
504 // |
193 // |
505 EXPORT_C TInt CVpnApItem::WriteUint( const TVpnApMember aColumn, |
194 EXPORT_C TInt CVpnApItem::WriteUint( const TVpnApMember aColumn, |
506 const TUint32& aValue ) |
195 const TUint32& aValue ) |
507 { |
196 { |
508 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteUint" ) ) ); |
197 return KErrNotSupported; |
509 |
|
510 TInt retval( KErrNone ); |
|
511 switch ( aColumn ) |
|
512 { |
|
513 case EApVpnWapAccessPointID: |
|
514 { |
|
515 iVpnWapId = aValue; |
|
516 break; |
|
517 } |
|
518 case EApVpnIapID: |
|
519 { |
|
520 iVpnIapId = aValue; |
|
521 break; |
|
522 } |
|
523 case EApVpnRealIapID: |
|
524 { |
|
525 iRealIapId= aValue; |
|
526 break; |
|
527 } |
|
528 case EApVpnRealWapID: |
|
529 { |
|
530 iVpnRealWapId = aValue; |
|
531 break; |
|
532 } |
|
533 case EApVpnProxyPortNumber: |
|
534 { |
|
535 iProxyPort = aValue; |
|
536 break; |
|
537 } |
|
538 case EApVpnHomeNetworkID: |
|
539 { |
|
540 iHomeNetwork = aValue; |
|
541 break; |
|
542 } |
|
543 case EApVpnIapNetworkID: |
|
544 { |
|
545 iVpnIapNetwork = aValue; |
|
546 break; |
|
547 } |
|
548 default : |
|
549 { |
|
550 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
551 retval = KErrInvalidColumn; |
|
552 } |
|
553 } |
|
554 |
|
555 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteUint" ) ) ); |
|
556 return retval; |
|
557 } |
198 } |
558 |
199 |
559 |
200 |
560 |
201 |
561 // --------------------------------------------------------- |
202 // --------------------------------------------------------- |
586 // CVpnApItem::WapUid |
217 // CVpnApItem::WapUid |
587 // --------------------------------------------------------- |
218 // --------------------------------------------------------- |
588 // |
219 // |
589 EXPORT_C TUint32 CVpnApItem::WapUid() const |
220 EXPORT_C TUint32 CVpnApItem::WapUid() const |
590 { |
221 { |
591 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::WapUid" ) ) ); |
222 return 0; |
592 |
|
593 return iVpnWapId; |
|
594 } |
223 } |
595 |
224 |
596 |
225 |
597 // --------------------------------------------------------- |
226 // --------------------------------------------------------- |
598 // CVpnApItem::Name |
227 // CVpnApItem::Name |
599 // --------------------------------------------------------- |
228 // --------------------------------------------------------- |
600 // |
229 // |
601 EXPORT_C const TDesC& CVpnApItem::Name() const |
230 EXPORT_C const TDesC& CVpnApItem::Name() const |
602 { |
231 { |
603 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::Name" ) ) ); |
232 User::Leave( KErrNotSupported ); |
604 |
|
605 return *iName; |
|
606 } |
233 } |
607 |
234 |
608 |
235 |
609 |
236 |
610 // --------------------------------------------------------- |
237 // --------------------------------------------------------- |
611 // CVpnApItem::ReAllocL |
238 // CVpnApItem::ReAllocL |
612 // --------------------------------------------------------- |
239 // --------------------------------------------------------- |
613 // |
240 // |
614 void CVpnApItem::ReAllocL(HBufC*& aDes, const TDesC16& aValue) |
241 void CVpnApItem::ReAllocL(HBufC*& aDes, const TDesC16& aValue) |
615 { |
242 { |
616 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReAllocL" ) ) ); |
|
617 |
|
618 // now remove 'invalid' chars (TABs) as they cause problems |
|
619 // in other places, like listboxes... |
|
620 HBufC* tmp = RemoveInvalidCharsLC( aValue ); |
|
621 delete aDes; |
|
622 aDes = tmp; |
|
623 CleanupStack::Pop( tmp ); |
|
624 |
|
625 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReAllocL" ) ) ); |
|
626 } |
243 } |
627 |
244 |
628 |
245 |
629 |
246 |
630 // --------------------------------------------------------- |
247 // --------------------------------------------------------- |
631 // CVpnApItem::RemoveInvalidCharsLC |
248 // CVpnApItem::RemoveInvalidCharsLC |
632 // --------------------------------------------------------- |
249 // --------------------------------------------------------- |
633 // |
250 // |
634 HBufC* CVpnApItem::RemoveInvalidCharsLC( const TDesC16& aInText ) |
251 HBufC* CVpnApItem::RemoveInvalidCharsLC( const TDesC16& aInText ) |
635 { |
252 { |
636 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::RemoveInvalidCharsLC" ) ) ); |
253 return NULL; |
637 |
|
638 TInt size = aInText.Length(); |
|
639 HBufC* aOutText = HBufC::NewLC( size ); |
|
640 TPtr ptr = aOutText->Des(); |
|
641 |
|
642 for ( TInt ii=0; ii<size; ++ii ) |
|
643 { |
|
644 TText ch = aInText[ii]; |
|
645 if ( ch == CEditableText::ETabCharacter ) |
|
646 { |
|
647 ch = ' '; |
|
648 } |
|
649 ptr.Append( ch ); |
|
650 } |
|
651 |
|
652 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::RemoveInvalidCharsLC" ) ) ); |
|
653 return aOutText; |
|
654 } |
254 } |
655 |
255 |
656 |
256 |
657 |
257 |
658 // --------------------------------------------------------- |
258 // --------------------------------------------------------- |
659 // CVpnApItem::HasProxy |
259 // CVpnApItem::HasProxy |
660 // --------------------------------------------------------- |
260 // --------------------------------------------------------- |
661 // |
261 // |
662 TBool CVpnApItem::HasProxy() const |
262 TBool CVpnApItem::HasProxy() const |
663 { |
263 { |
664 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::HasProxy" ) ) ); |
264 return EFalse; |
665 |
|
666 TBool retval ( EFalse ); |
|
667 |
|
668 if ( ( iProxyServerAddress->Compare( KDynIpAddress ) |
|
669 && iProxyServerAddress->Compare( KEmpty ) ) |
|
670 && ( iProxyPort != 0 ) ) |
|
671 { |
|
672 retval = ETrue; |
|
673 } |
|
674 |
|
675 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::HasProxy" ) ) ); |
|
676 |
|
677 return retval; |
|
678 } |
265 } |
679 |
266 |
680 // End of File |
267 // End of File |