46 CmConnectionMethodShim *cmConnectionMethod, |
62 CmConnectionMethodShim *cmConnectionMethod, |
47 QGraphicsItem *parent) : |
63 QGraphicsItem *parent) : |
48 CpBaseSettingView(0, parent), |
64 CpBaseSettingView(0, parent), |
49 mForm(0), |
65 mForm(0), |
50 mModel(0), |
66 mModel(0), |
51 mCmConnectionMethod(cmConnectionMethod) |
67 mCmConnectionMethod(cmConnectionMethod), |
52 { |
68 mIpv4Group(0), |
|
69 mIpv4Automatic(0), |
|
70 mIpv4Address(0), |
|
71 mIpv4SubnetMask(0), |
|
72 mIpv4Gateway(0), |
|
73 mIpv4DnsAutomatic(0), |
|
74 mIpv4DnsAddress1(0), |
|
75 mIpv4DnsAddress2(0), |
|
76 mIpv6Group(0), |
|
77 mIpv6DnsAutomatic(0), |
|
78 mIpv6DnsAddress1(0), |
|
79 mIpv6DnsAddress2(0), |
|
80 mProxyGroup(0), |
|
81 mProxyServer(0), |
|
82 mProxyPort(0), |
|
83 mMessageBox(0), |
|
84 mIpv6Supported(false) |
|
85 { |
|
86 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_ENTRY); |
|
87 |
53 // Construct WLAN AP advanced settings UI |
88 // Construct WLAN AP advanced settings UI |
54 mForm = new HbDataForm(); |
89 mForm = new HbDataForm(); |
55 this->setWidget(mForm); |
90 this->setWidget(mForm); |
56 mModel = new HbDataFormModel(mForm); |
91 mModel = new HbDataFormModel(mForm); |
57 mForm->setModel(mModel); |
92 mForm->setModel(mModel); |
58 |
93 |
|
94 mIpv6Supported = mCmConnectionMethod->getBoolAttribute( |
|
95 CMManagerShim::CmIPv6Supported); |
|
96 |
59 // Add advanced settings groups |
97 // Add advanced settings groups |
60 createAdvancedSettings(); |
98 createAdvancedSettings(); |
|
99 |
|
100 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT); |
61 } |
101 } |
62 |
102 |
63 /*! |
103 /*! |
64 Destructor. |
104 Destructor. |
65 */ |
105 */ |
66 CpWlanApAdvancedView::~CpWlanApAdvancedView() |
106 CpWlanApAdvancedView::~CpWlanApAdvancedView() |
67 { |
107 { |
|
108 OstTraceFunctionEntry0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_ENTRY); |
|
109 |
|
110 OstTraceFunctionExit0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT); |
68 } |
111 } |
69 |
112 |
70 /*! |
113 /*! |
71 Creates all advanced settings groups. |
114 Creates all advanced settings groups. |
72 */ |
115 */ |
73 void CpWlanApAdvancedView::createAdvancedSettings() |
116 void CpWlanApAdvancedView::createAdvancedSettings() |
74 { |
117 { |
75 // TODO: Implement the advanced settings view. |
118 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_ENTRY); |
76 } |
119 |
|
120 // Create settings groups |
|
121 createIpv4Group(); |
|
122 if (mIpv6Supported) { |
|
123 createIpv6Group(); |
|
124 } |
|
125 createProxyGroup(); |
|
126 |
|
127 // Read values and update UI |
|
128 updateIpv4Group(); |
|
129 if (mIpv6Supported) { |
|
130 updateIpv6Group(); |
|
131 } |
|
132 updateProxyGroup(); |
|
133 |
|
134 // Connect signal to initialize settings item widgets |
|
135 bool status = connect( |
|
136 mForm, |
|
137 SIGNAL(itemShown(const QModelIndex)), |
|
138 this, |
|
139 SLOT(setEditorPreferences(const QModelIndex))); |
|
140 Q_ASSERT(status); |
|
141 |
|
142 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_EXIT); |
|
143 } |
|
144 |
|
145 /*! |
|
146 Creates the IPv4 settings group. |
|
147 */ |
|
148 void CpWlanApAdvancedView::createIpv4Group() |
|
149 { |
|
150 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEIPV4GROUP_ENTRY); |
|
151 |
|
152 // IPv4 settings group |
|
153 mIpv4Group = new CpSettingFormItemData( |
|
154 HbDataFormModelItem::GroupItem, |
|
155 hbTrId("txt_occ_subhead_ipv4_settings")); |
|
156 mModel->appendDataFormItem(mIpv4Group); |
|
157 |
|
158 // Phone IP address |
|
159 // "Automatic" checkbox |
|
160 mIpv4Automatic = new CpSettingFormItemData( |
|
161 HbDataFormModelItem::CheckBoxItem, |
|
162 hbTrId("txt_occ_setlabel_phone_ip_address")); |
|
163 mIpv4Automatic->setContentWidgetData( |
|
164 "text", |
|
165 hbTrId("txt_occ_setlabel_val_automatic")); |
|
166 mForm->addConnection( |
|
167 mIpv4Automatic, |
|
168 SIGNAL(stateChanged(int)), |
|
169 this, |
|
170 SLOT(changeIpv4AddressMode(int))); |
|
171 mIpv4Group->appendChild(mIpv4Automatic); |
|
172 |
|
173 // Phone IP address |
|
174 mIpv4Address = new CpSettingFormItemData( |
|
175 HbDataFormModelItem::TextItem, |
|
176 hbTrId("txt_occ_setlabel_phone_ip_address")); |
|
177 mForm->addConnection( |
|
178 mIpv4Address, |
|
179 SIGNAL(editingFinished()), |
|
180 this, |
|
181 SLOT(changeIpv4Address())); |
|
182 mIpv4Group->appendChild(mIpv4Address); |
|
183 |
|
184 // Subnet mask |
|
185 mIpv4SubnetMask = new CpSettingFormItemData( |
|
186 HbDataFormModelItem::TextItem, |
|
187 hbTrId("txt_occ_setlabel_subnet_mask")); |
|
188 mForm->addConnection( |
|
189 mIpv4SubnetMask, |
|
190 SIGNAL(editingFinished()), |
|
191 this, |
|
192 SLOT(changeIpv4SubnetMask())); |
|
193 mIpv4Group->appendChild(mIpv4SubnetMask); |
|
194 |
|
195 // Gateway |
|
196 mIpv4Gateway = new CpSettingFormItemData( |
|
197 HbDataFormModelItem::TextItem, |
|
198 hbTrId("txt_occ_setlabel_default_gateway")); |
|
199 mForm->addConnection( |
|
200 mIpv4Gateway, |
|
201 SIGNAL(editingFinished()), |
|
202 this, |
|
203 SLOT(changeIpv4Gateway())); |
|
204 mIpv4Group->appendChild(mIpv4Gateway); |
|
205 |
|
206 // DNS addresses |
|
207 // "Automatic" checkbox |
|
208 mIpv4DnsAutomatic = new CpSettingFormItemData( |
|
209 HbDataFormModelItem::CheckBoxItem, |
|
210 hbTrId("txt_occ_setlabel_dns_addresses")); |
|
211 mIpv4DnsAutomatic->setContentWidgetData( |
|
212 "text", |
|
213 hbTrId("txt_occ_setlabel_val_automatic")); |
|
214 mForm->addConnection( |
|
215 mIpv4DnsAutomatic, |
|
216 SIGNAL(stateChanged(int)), |
|
217 this, |
|
218 SLOT(changeIpv4DnsMode(int))); |
|
219 mIpv4Group->appendChild(mIpv4DnsAutomatic); |
|
220 |
|
221 // Primary DNS address |
|
222 mIpv4DnsAddress1 = new CpSettingFormItemData( |
|
223 HbDataFormModelItem::TextItem, |
|
224 hbTrId("txt_occ_setlabel_primary_name_server")); |
|
225 mForm->addConnection( |
|
226 mIpv4DnsAddress1, |
|
227 SIGNAL(editingFinished()), |
|
228 this, |
|
229 SLOT(changeIpv4PrimaryDnsAddress())); |
|
230 mIpv4Group->appendChild(mIpv4DnsAddress1); |
|
231 |
|
232 // Secondary DNS address |
|
233 mIpv4DnsAddress2 = new CpSettingFormItemData( |
|
234 HbDataFormModelItem::TextItem, |
|
235 hbTrId("txt_occ_setlabel_secondary_name_server")); |
|
236 mForm->addConnection( |
|
237 mIpv4DnsAddress2, |
|
238 SIGNAL(editingFinished()), |
|
239 this, |
|
240 SLOT(changeIpv4SecondaryDnsAddress())); |
|
241 mIpv4Group->appendChild(mIpv4DnsAddress2); |
|
242 |
|
243 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV4GROUP_EXIT); |
|
244 } |
|
245 |
|
246 /*! |
|
247 Reads attribute values and updates the IPv4 settings group. |
|
248 */ |
|
249 void CpWlanApAdvancedView::updateIpv4Group() |
|
250 { |
|
251 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_ENTRY); |
|
252 |
|
253 // Phone IP address |
|
254 // "Automatic" checkbox |
|
255 bool ipAddressFromServer = mCmConnectionMethod->getBoolAttribute( |
|
256 CMManagerShim::CmIPAddrFromServer); |
|
257 Qt::CheckState state = Qt::Unchecked; |
|
258 if (ipAddressFromServer) { |
|
259 state = Qt::Checked; |
|
260 } |
|
261 mIpv4Automatic->setContentWidgetData("checkState", state); |
|
262 |
|
263 // Enable/disable user defined IP address fields |
|
264 enableIpv4AddressFields(state); |
|
265 |
|
266 // Phone IP address |
|
267 QString string = getIpAddress(CMManagerShim::CmIPAddress); |
|
268 mIpv4Address->setContentWidgetData("text", string); |
|
269 |
|
270 // Subnet mask |
|
271 string = getIpAddress(CMManagerShim::CmIPNetmask); |
|
272 mIpv4SubnetMask->setContentWidgetData("text", string); |
|
273 |
|
274 // Gateway |
|
275 string = getIpAddress(CMManagerShim::CmIPGateway); |
|
276 mIpv4Gateway->setContentWidgetData("text", string); |
|
277 |
|
278 // DNS addresses |
|
279 // "Automatic" checkbox |
|
280 state = Qt::Unchecked; |
|
281 if (mCmConnectionMethod->getBoolAttribute( |
|
282 CMManagerShim::CmIPDNSAddrFromServer)) { |
|
283 state = Qt::Checked; |
|
284 } |
|
285 mIpv4DnsAutomatic->setContentWidgetData("checkState", state); |
|
286 |
|
287 // Enable/disable user defined DNS address fields |
|
288 enableIpv4DnsFields(state); |
|
289 |
|
290 // Primary DNS address |
|
291 string = getIpAddress(CMManagerShim::CmIPNameServer1); |
|
292 mIpv4DnsAddress1->setContentWidgetData("text", string); |
|
293 |
|
294 // Secondary DNS address |
|
295 string = getIpAddress(CMManagerShim::CmIPNameServer2); |
|
296 mIpv4DnsAddress2->setContentWidgetData("text", string); |
|
297 |
|
298 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_EXIT); |
|
299 } |
|
300 |
|
301 /*! |
|
302 Creates the IPv6 settings group. |
|
303 */ |
|
304 void CpWlanApAdvancedView::createIpv6Group() |
|
305 { |
|
306 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_ENTRY); |
|
307 |
|
308 // IPv6 settings group |
|
309 mIpv6Group = new CpSettingFormItemData( |
|
310 HbDataFormModelItem::GroupItem, |
|
311 hbTrId("txt_occ_subhead_ipv6_settings")); |
|
312 mModel->appendDataFormItem(mIpv6Group); |
|
313 |
|
314 // DNS addresses |
|
315 // Automatic/well-known/user defined combobox |
|
316 mIpv6DnsAutomatic = new CpSettingFormItemData( |
|
317 HbDataFormModelItem::ComboBoxItem, |
|
318 hbTrId("txt_occ_setlabel_dns_addresses")); |
|
319 QStringList dnsModeList; |
|
320 // Order of the list must match the Ipv6DnsType enum |
|
321 dnsModeList |
|
322 << hbTrId("txt_occ_setlabel_val_automatic") |
|
323 << hbTrId("txt_occ_setlabel_dns_addresses_val_wellknown") |
|
324 << hbTrId("txt_occ_setlabel_dns_addresses_val_user_defined"); |
|
325 mIpv6DnsAutomatic->setContentWidgetData("items", dnsModeList); |
|
326 mForm->addConnection( |
|
327 mIpv6DnsAutomatic, |
|
328 SIGNAL(currentIndexChanged(int)), |
|
329 this, |
|
330 SLOT(changeIpv6DnsMode(int))); |
|
331 mIpv6Group->appendChild(mIpv6DnsAutomatic); |
|
332 |
|
333 // Primary DNS address |
|
334 mIpv6DnsAddress1 = new CpSettingFormItemData( |
|
335 HbDataFormModelItem::TextItem, |
|
336 hbTrId("txt_occ_setlabel_primary_name_server")); |
|
337 mForm->addConnection( |
|
338 mIpv6DnsAddress1, |
|
339 SIGNAL(editingFinished()), |
|
340 this, |
|
341 SLOT(changeIpv6PrimaryDnsAddress())); |
|
342 mIpv6Group->appendChild(mIpv6DnsAddress1); |
|
343 |
|
344 // Secondary DNS address |
|
345 mIpv6DnsAddress2 = new CpSettingFormItemData( |
|
346 HbDataFormModelItem::TextItem, |
|
347 hbTrId("txt_occ_setlabel_secondary_name_server")); |
|
348 mForm->addConnection( |
|
349 mIpv6DnsAddress2, |
|
350 SIGNAL(editingFinished()), |
|
351 this, |
|
352 SLOT(changeIpv6SecondaryDnsAddress())); |
|
353 mIpv6Group->appendChild(mIpv6DnsAddress2); |
|
354 |
|
355 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_EXIT); |
|
356 } |
|
357 |
|
358 /*! |
|
359 Reads attribute values and updates the IPv6 settings group. |
|
360 */ |
|
361 void CpWlanApAdvancedView::updateIpv6Group() |
|
362 { |
|
363 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_ENTRY); |
|
364 |
|
365 // DNS addresses |
|
366 // Automatic/well-known/user defined combobox |
|
367 uint type = getIpv6DnsType(); |
|
368 mIpv6DnsAutomatic->setContentWidgetData("currentIndex", type); |
|
369 |
|
370 // Enable/disable user defined DNS address fields |
|
371 enableIpv6DnsFields(type); |
|
372 |
|
373 // Primary DNS address |
|
374 QString string = getIpAddress(CMManagerShim::CmIP6NameServer1); |
|
375 mIpv6DnsAddress1->setContentWidgetData("text", string); |
|
376 |
|
377 // Secondary DNS address |
|
378 string = getIpAddress(CMManagerShim::CmIP6NameServer2); |
|
379 mIpv6DnsAddress2->setContentWidgetData("text", string); |
|
380 |
|
381 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_EXIT); |
|
382 } |
|
383 |
|
384 /*! |
|
385 Creates the proxy settings group. |
|
386 */ |
|
387 void CpWlanApAdvancedView::createProxyGroup() |
|
388 { |
|
389 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_ENTRY); |
|
390 |
|
391 // Proxy settings group |
|
392 mProxyGroup = new CpSettingFormItemData( |
|
393 HbDataFormModelItem::GroupItem, |
|
394 hbTrId("txt_occ_subhead_proxy_settings")); |
|
395 mModel->appendDataFormItem(mProxyGroup); |
|
396 |
|
397 // Proxy server address |
|
398 mProxyServer = new CpSettingFormItemData( |
|
399 HbDataFormModelItem::TextItem, |
|
400 hbTrId("txt_occ_setlabel_proxy_server_address")); |
|
401 mForm->addConnection( |
|
402 mProxyServer, |
|
403 SIGNAL(editingFinished()), |
|
404 this, |
|
405 SLOT(changeProxyServer())); |
|
406 mProxyGroup->appendChild(mProxyServer); |
|
407 |
|
408 // Proxy port number |
|
409 mProxyPort = new CpSettingFormItemData( |
|
410 HbDataFormModelItem::TextItem, |
|
411 hbTrId("txt_occ_setlabel_proxy_port_number")); |
|
412 mForm->addConnection( |
|
413 mProxyPort, |
|
414 SIGNAL(editingFinished()), |
|
415 this, |
|
416 SLOT(changeProxyPort())); |
|
417 mProxyGroup->appendChild(mProxyPort); |
|
418 |
|
419 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_EXIT); |
|
420 } |
|
421 |
|
422 /*! |
|
423 Reads attribute values and updates the proxy settings group. |
|
424 */ |
|
425 void CpWlanApAdvancedView::updateProxyGroup() |
|
426 { |
|
427 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_ENTRY); |
|
428 |
|
429 // Proxy server address |
|
430 QString serverAddress = mCmConnectionMethod->getStringAttribute( |
|
431 CMManagerShim::CmProxyServerName); |
|
432 mProxyServer->setContentWidgetData("text", serverAddress); |
|
433 |
|
434 // Proxy port number |
|
435 uint portNumber = mCmConnectionMethod->getIntAttribute( |
|
436 CMManagerShim::CmProxyPortNumber); |
|
437 if (portNumber > 0) { |
|
438 mProxyPort->setContentWidgetData("text", QVariant(portNumber)); |
|
439 } else { |
|
440 mProxyPort->setContentWidgetData("text", ""); |
|
441 } |
|
442 |
|
443 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_EXIT); |
|
444 } |
|
445 |
|
446 /*! |
|
447 Reads an IP address from CommsDat with given attribute. If string is |
|
448 empty, a zero address (0.0.0.0 or 0:0:0:0:0:0:0:0) is returned. |
|
449 */ |
|
450 QString CpWlanApAdvancedView::getIpAddress( |
|
451 CMManagerShim::ConnectionMethodAttribute attribute) |
|
452 { |
|
453 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_ENTRY); |
|
454 |
|
455 QString ipAddress = mCmConnectionMethod->getStringAttribute(attribute); |
|
456 |
|
457 if (ipAddress.isEmpty()) { |
|
458 // String is empty, return a zero address instead |
|
459 switch (attribute) { |
|
460 case CMManagerShim::CmIP6NameServer1: |
|
461 case CMManagerShim::CmIP6NameServer2: |
|
462 // IPv6 address |
|
463 ipAddress = CMManagerShim::DynamicIpv6Address; |
|
464 break; |
|
465 default: |
|
466 // IPv4 address |
|
467 ipAddress = CMManagerShim::UnspecifiedIpv4Address; |
|
468 break; |
|
469 } |
|
470 } |
|
471 |
|
472 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_EXIT); |
|
473 return ipAddress; |
|
474 } |
|
475 |
|
476 /*! |
|
477 Resolves IPv6 DNS address type. |
|
478 */ |
|
479 CpWlanApAdvancedView::Ipv6DnsType CpWlanApAdvancedView::getIpv6DnsType() |
|
480 { |
|
481 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_ENTRY); |
|
482 |
|
483 // Read "DNS address from server" flag |
|
484 bool dnsAddressFromServer = mCmConnectionMethod->getBoolAttribute( |
|
485 CMManagerShim::CmIP6DNSAddrFromServer); |
|
486 |
|
487 // Read IPv6 DNS addresses from CommsDat |
|
488 QString primaryAddress = mCmConnectionMethod->getStringAttribute( |
|
489 CMManagerShim::CmIP6NameServer1); |
|
490 QString secondaryAddress = mCmConnectionMethod->getStringAttribute( |
|
491 CMManagerShim::CmIP6NameServer2); |
|
492 |
|
493 // Resolve IPv6 DNS address type |
|
494 Ipv6DnsType type = Ipv6DnsTypeUserDefined; |
|
495 if (dnsAddressFromServer) { |
|
496 // Automatic |
|
497 type = Ipv6DnsTypeAutomatic; |
|
498 } else if (primaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer1 |
|
499 && secondaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer2) { |
|
500 // Well-known IPv6 DNS addresses |
|
501 type = Ipv6DnsTypeWellKnown; |
|
502 } |
|
503 |
|
504 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_EXIT); |
|
505 return type; |
|
506 } |
|
507 |
|
508 /*! |
|
509 Sets IPv4 address field enabled/disabled. |
|
510 */ |
|
511 void CpWlanApAdvancedView::enableIpv4AddressFields(int state) |
|
512 { |
|
513 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_ENTRY); |
|
514 |
|
515 if (state == Qt::Checked) { |
|
516 // Automatic, disable text field |
|
517 mIpv4Address->setEnabled(false); |
|
518 mIpv4SubnetMask->setEnabled(false); |
|
519 mIpv4Gateway->setEnabled(false); |
|
520 } else { |
|
521 // Manual, enable text field |
|
522 mIpv4Address->setEnabled(true); |
|
523 mIpv4SubnetMask->setEnabled(true); |
|
524 mIpv4Gateway->setEnabled(true); |
|
525 } |
|
526 |
|
527 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_EXIT); |
|
528 } |
|
529 |
|
530 /*! |
|
531 Sets IPv4 DNS address fields enabled/disabled. |
|
532 */ |
|
533 void CpWlanApAdvancedView::enableIpv4DnsFields(int state) |
|
534 { |
|
535 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_ENTRY); |
|
536 |
|
537 if (state == Qt::Checked) { |
|
538 // Automatic, disable text fields |
|
539 mIpv4DnsAddress1->setEnabled(false); |
|
540 mIpv4DnsAddress2->setEnabled(false); |
|
541 } else { |
|
542 // Manual, enable text fields |
|
543 mIpv4DnsAddress1->setEnabled(true); |
|
544 mIpv4DnsAddress2->setEnabled(true); |
|
545 } |
|
546 |
|
547 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_EXIT); |
|
548 } |
|
549 |
|
550 /*! |
|
551 Sets IPv6 DNS address fields enabled/disabled. |
|
552 */ |
|
553 void CpWlanApAdvancedView::enableIpv6DnsFields(int selectionIndex) |
|
554 { |
|
555 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_ENTRY); |
|
556 |
|
557 // Check combobox value |
|
558 if (selectionIndex == Ipv6DnsTypeUserDefined) { |
|
559 // User-defined, enable text fields |
|
560 mIpv6DnsAddress1->setEnabled(true); |
|
561 mIpv6DnsAddress2->setEnabled(true); |
|
562 } else { |
|
563 // Automatic or well-known, disable text fields |
|
564 mIpv6DnsAddress1->setEnabled(false); |
|
565 mIpv6DnsAddress2->setEnabled(false); |
|
566 } |
|
567 |
|
568 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_EXIT); |
|
569 } |
|
570 |
|
571 /*! |
|
572 Validates an IP address and saves it to CommsDat in case it was a valid |
|
573 address or an empty string. In case the address is not valid, an error |
|
574 note is shown to the user and previous setting is restored to the UI. |
|
575 */ |
|
576 bool CpWlanApAdvancedView::validateAndSaveIpAddress( |
|
577 HbDataFormModelItem *item, |
|
578 CMManagerShim::ConnectionMethodAttribute attribute, |
|
579 QAbstractSocket::NetworkLayerProtocol protocol) |
|
580 { |
|
581 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_ENTRY); |
|
582 |
|
583 bool success = false; |
|
584 |
|
585 // Check address |
|
586 QString address = item->contentWidgetData("text").toString(); |
|
587 QHostAddress hostAddress; |
|
588 if (hostAddress.setAddress(address) |
|
589 && hostAddress.protocol() == protocol) { |
|
590 // Proper address, convert to lower case (IPv6) |
|
591 address = hostAddress.toString().toLower(); |
|
592 } else if (address.isEmpty()) { |
|
593 // Empty string, replace with 0.0.0.0 or 0:0:0:0:0:0:0:0 |
|
594 if (protocol == QAbstractSocket::IPv4Protocol) { |
|
595 address = CMManagerShim::UnspecifiedIpv4Address; |
|
596 } else { |
|
597 address = CMManagerShim::DynamicIpv6Address; |
|
598 } |
|
599 } else { |
|
600 // Invalid address |
|
601 address.clear(); |
|
602 } |
|
603 |
|
604 if (!address.isEmpty()) { |
|
605 // Save to CommsDat |
|
606 mCmConnectionMethod->setStringAttribute(attribute, address); |
|
607 if (tryUpdate()) { |
|
608 success = true; |
|
609 item->setContentWidgetData("text", address); |
|
610 } |
|
611 } else { |
|
612 // Inform user of invalid name |
|
613 showMessageBox( |
|
614 HbMessageBox::MessageTypeInformation, |
|
615 hbTrId("txt_occ_info_invalid_input")); |
|
616 // Restore previous setting |
|
617 address = getIpAddress(attribute); |
|
618 item->setContentWidgetData("text", address); |
|
619 } |
|
620 |
|
621 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_EXIT); |
|
622 return success; |
|
623 } |
|
624 |
|
625 /*! |
|
626 Shows message box with "OK" button using given text. |
|
627 */ |
|
628 void CpWlanApAdvancedView::showMessageBox( |
|
629 HbMessageBox::MessageBoxType type, |
|
630 const QString &text) |
|
631 { |
|
632 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_ENTRY); |
|
633 |
|
634 // Create a message box |
|
635 mMessageBox = QSharedPointer<HbMessageBox>(new HbMessageBox(type)); |
|
636 mMessageBox->setText(text); |
|
637 mMessageBox->setModal(true); |
|
638 mMessageBox->setTimeout(HbPopup::NoTimeout); |
|
639 mMessageBox->setDismissPolicy(HbPopup::NoDismiss); |
|
640 mMessageBox->open(); |
|
641 |
|
642 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_EXIT); |
|
643 } |
|
644 |
|
645 /*! |
|
646 Tries to update connection method changes to CommsDat. |
|
647 Returns "true" if success, "false" if some error happened. |
|
648 */ |
|
649 bool CpWlanApAdvancedView::tryUpdate() |
|
650 { |
|
651 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_TRYUPDATE_ENTRY); |
|
652 |
|
653 // Try update |
|
654 bool success = true; |
|
655 try { |
|
656 mCmConnectionMethod->update(); |
|
657 } |
|
658 catch (const std::exception&) { |
|
659 // Handle error |
|
660 handleUpdateError(); |
|
661 |
|
662 success = false; |
|
663 } |
|
664 |
|
665 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_TRYUPDATE_EXIT); |
|
666 return success; |
|
667 } |
|
668 |
|
669 /*! |
|
670 Handles failed CommsDat update. |
|
671 */ |
|
672 void CpWlanApAdvancedView::handleUpdateError() |
|
673 { |
|
674 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_ENTRY); |
|
675 |
|
676 // Show error note to user |
|
677 showMessageBox( |
|
678 HbMessageBox::MessageTypeWarning, |
|
679 hbTrId("txt_occ_info_unable_to_save_setting")); |
|
680 // Reload settings from CommsDat and update UI |
|
681 try { |
|
682 mCmConnectionMethod->refresh(); |
|
683 } |
|
684 catch (const std::exception&) { |
|
685 // Ignore error from refresh. Most likely this will not happen, but |
|
686 // if it does, there isn't very much we can do. |
|
687 OstTrace0( |
|
688 TRACE_ERROR, |
|
689 CPWLANAPPADVANCEDVIEW_HANDLEUPDATEERROR, |
|
690 "Refresh failed"); |
|
691 }; |
|
692 updateIpv4Group(); |
|
693 if (mIpv6Supported) { |
|
694 updateIpv6Group(); |
|
695 } |
|
696 updateProxyGroup(); |
|
697 |
|
698 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_EXIT); |
|
699 } |
|
700 |
|
701 /*! |
|
702 Initializes all settings groups. |
|
703 */ |
|
704 void CpWlanApAdvancedView::setEditorPreferences(const QModelIndex index) |
|
705 { |
|
706 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_ENTRY); |
|
707 |
|
708 HbDataFormViewItem *viewItem = qobject_cast<HbDataFormViewItem *> |
|
709 (mForm->itemByIndex(index)); |
|
710 HbDataFormModelItem *modelItem = mModel->itemFromIndex(index); |
|
711 |
|
712 if (modelItem == mIpv4Address |
|
713 || modelItem == mIpv4SubnetMask |
|
714 || modelItem == mIpv4Gateway |
|
715 || modelItem == mIpv4DnsAddress1 |
|
716 || modelItem == mIpv4DnsAddress2 |
|
717 || modelItem == mIpv6DnsAddress1 |
|
718 || modelItem == mIpv6DnsAddress2 |
|
719 || modelItem == mProxyServer |
|
720 || modelItem == mProxyPort) { |
|
721 // HbLineEdit items, get editor and editor interface |
|
722 HbLineEdit *edit = qobject_cast<HbLineEdit *> |
|
723 (viewItem->dataItemContentWidget()); |
|
724 HbEditorInterface editorInterface(edit); |
|
725 |
|
726 if (modelItem == mIpv4Address |
|
727 || modelItem == mIpv4SubnetMask |
|
728 || modelItem == mIpv4Gateway |
|
729 || modelItem == mIpv4DnsAddress1 |
|
730 || modelItem == mIpv4DnsAddress2) { |
|
731 // IPv4 IP address |
|
732 editorInterface.setMode(HbInputModeNumeric); |
|
733 editorInterface.setFilter(CpIpv4Filter::instance()); |
|
734 edit->setMaxLength(CMManagerShim::CmIP4AddressLength); |
|
735 } else if (modelItem == mIpv6DnsAddress1 |
|
736 || modelItem == mIpv6DnsAddress2) { |
|
737 // IPv6 IP address |
|
738 editorInterface.setInputConstraints( |
|
739 HbEditorConstraintLatinAlphabetOnly); |
|
740 editorInterface.setFilter(CpIpv6Filter::instance()); |
|
741 edit->setInputMethodHints( |
|
742 Qt::ImhNoPredictiveText |
|
743 | Qt::ImhPreferLowercase); |
|
744 edit->setMaxLength(CMManagerShim::CmIP6NameServerLength); |
|
745 } else if (modelItem == mProxyServer) { |
|
746 // Proxy server address |
|
747 editorInterface.setMode(HbInputModeNone); |
|
748 editorInterface.setInputConstraints( |
|
749 HbEditorConstraintLatinAlphabetOnly); |
|
750 editorInterface.setFilter(HbUrlFilter::instance()); |
|
751 editorInterface.setEditorClass(HbInputEditorClassUrl); |
|
752 editorInterface.setDigitType(HbDigitTypeNone); |
|
753 edit->setInputMethodHints( |
|
754 Qt::ImhNoPredictiveText |
|
755 | Qt::ImhPreferLowercase); |
|
756 edit->setMaxLength(CMManagerShim::CmProxyServerNameLength); |
|
757 } else { /* mProxyPort */ |
|
758 // Proxy port number |
|
759 editorInterface.setMode(HbInputModeNumeric); |
|
760 edit->setInputMethodHints(Qt::ImhDigitsOnly); |
|
761 edit->setMaxLength(CMManagerShim::CmProxyPortNumberLength); |
|
762 } |
|
763 } |
|
764 |
|
765 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_EXIT); |
|
766 } |
|
767 |
|
768 /*! |
|
769 Handles change to IPv4 address mode (automatic/user defined). |
|
770 */ |
|
771 void CpWlanApAdvancedView::changeIpv4AddressMode(int state) |
|
772 { |
|
773 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_ENTRY); |
|
774 |
|
775 bool ipv4AddressFromServer; |
|
776 if (state == Qt::Checked) { |
|
777 ipv4AddressFromServer = true; |
|
778 } else { |
|
779 ipv4AddressFromServer = false; |
|
780 } |
|
781 |
|
782 if (!ipv4AddressFromServer |
|
783 && getIpAddress(CMManagerShim::CmIPAddress) == |
|
784 CMManagerShim::UnspecifiedIpv4Address) { |
|
785 // User defined IP address selected, but no valid address is stored. |
|
786 // Just enable the UI IP editors, because CMManager will update the |
|
787 // "IP address from server" flag by itself when a valid IP address |
|
788 // is stored. |
|
789 enableIpv4AddressFields(state); |
|
790 } else { |
|
791 // Save setting to CommsDat |
|
792 mCmConnectionMethod->setBoolAttribute( |
|
793 CMManagerShim::CmIPAddrFromServer, |
|
794 ipv4AddressFromServer); |
|
795 if (tryUpdate()) { |
|
796 enableIpv4AddressFields(state); |
|
797 } |
|
798 } |
|
799 |
|
800 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_EXIT); |
|
801 } |
|
802 |
|
803 /*! |
|
804 Saves IPv4 address to CommsDat. |
|
805 */ |
|
806 void CpWlanApAdvancedView::changeIpv4Address() |
|
807 { |
|
808 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_ENTRY); |
|
809 |
|
810 if (validateAndSaveIpAddress( |
|
811 mIpv4Address, |
|
812 CMManagerShim::CmIPAddress, |
|
813 QAbstractSocket::IPv4Protocol)) { |
|
814 // In case the IP address is empty or 0.0.0.0, CMManager changes the |
|
815 // "IP address from server" flag to true. We need to refresh the UI to |
|
816 // make sure we are in sync. |
|
817 updateIpv4Group(); |
|
818 } |
|
819 |
|
820 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_EXIT); |
|
821 } |
|
822 |
|
823 /*! |
|
824 Saves IPv4 subnet mask to CommsDat. |
|
825 */ |
|
826 void CpWlanApAdvancedView::changeIpv4SubnetMask() |
|
827 { |
|
828 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_ENTRY); |
|
829 |
|
830 (void)validateAndSaveIpAddress( |
|
831 mIpv4SubnetMask, |
|
832 CMManagerShim::CmIPNetmask, |
|
833 QAbstractSocket::IPv4Protocol); |
|
834 |
|
835 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_EXIT); |
|
836 } |
|
837 |
|
838 /*! |
|
839 Saves IPv4 gateway to CommsDat. |
|
840 */ |
|
841 void CpWlanApAdvancedView::changeIpv4Gateway() |
|
842 { |
|
843 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_ENTRY); |
|
844 |
|
845 (void)validateAndSaveIpAddress( |
|
846 mIpv4Gateway, |
|
847 CMManagerShim::CmIPGateway, |
|
848 QAbstractSocket::IPv4Protocol); |
|
849 |
|
850 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_EXIT); |
|
851 } |
|
852 |
|
853 /*! |
|
854 Handles change to IPv4 DNS mode (automatic/user defined). |
|
855 */ |
|
856 void CpWlanApAdvancedView::changeIpv4DnsMode(int state) |
|
857 { |
|
858 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_ENTRY); |
|
859 |
|
860 bool dnsAddressFromServer; |
|
861 if (state == Qt::Checked) { |
|
862 dnsAddressFromServer = true; |
|
863 } else { |
|
864 dnsAddressFromServer = false; |
|
865 } |
|
866 // Save setting to CommsDat |
|
867 mCmConnectionMethod->setBoolAttribute( |
|
868 CMManagerShim::CmIPDNSAddrFromServer, |
|
869 dnsAddressFromServer); |
|
870 if (tryUpdate()) { |
|
871 enableIpv4DnsFields(state); |
|
872 } |
|
873 |
|
874 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_EXIT); |
|
875 } |
|
876 |
|
877 /*! |
|
878 Saves IPv4 primary DNS address to CommsDat. |
|
879 */ |
|
880 void CpWlanApAdvancedView::changeIpv4PrimaryDnsAddress() |
|
881 { |
|
882 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_ENTRY); |
|
883 |
|
884 if (validateAndSaveIpAddress( |
|
885 mIpv4DnsAddress1, |
|
886 CMManagerShim::CmIPNameServer1, |
|
887 QAbstractSocket::IPv4Protocol)) { |
|
888 // Address saved successfully, update "DNS address from server" flag |
|
889 mCmConnectionMethod->setBoolAttribute( |
|
890 CMManagerShim::CmIPDNSAddrFromServer, |
|
891 false); |
|
892 if (tryUpdate()) { |
|
893 // In case primary DNS address is empty or 0.0.0.0, CMManager will |
|
894 // check secondary DNS address and in case it is a valid address, |
|
895 // move it to the primary DNS address. We need to refresh the |
|
896 // UI to make sure we are in sync. If tryUpdate() fails it does |
|
897 // the refresh automatically, so only success case is handled |
|
898 // here. |
|
899 updateIpv4Group(); |
|
900 } |
|
901 } |
|
902 |
|
903 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_EXIT); |
|
904 } |
|
905 |
|
906 /*! |
|
907 Saves IPv4 secondary DNS address to CommsDat. |
|
908 */ |
|
909 void CpWlanApAdvancedView::changeIpv4SecondaryDnsAddress() |
|
910 { |
|
911 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_ENTRY); |
|
912 |
|
913 if (validateAndSaveIpAddress( |
|
914 mIpv4DnsAddress2, |
|
915 CMManagerShim::CmIPNameServer2, |
|
916 QAbstractSocket::IPv4Protocol)) { |
|
917 // Address saved successfully, update "DNS address from server" flag |
|
918 mCmConnectionMethod->setBoolAttribute( |
|
919 CMManagerShim::CmIPDNSAddrFromServer, |
|
920 false); |
|
921 if (tryUpdate()) { |
|
922 // In case primary DNS address is empty or 0.0.0.0, CMManager will |
|
923 // write the address there instead of secondary DNS address, so we |
|
924 // need to refresh the UI to make sure we are in sync. If |
|
925 // tryUpdate() fails it does the refresh automatically, so only |
|
926 // success case is handled here. |
|
927 updateIpv4Group(); |
|
928 } |
|
929 } |
|
930 |
|
931 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_EXIT); |
|
932 } |
|
933 |
|
934 /*! |
|
935 Handles change to IPv6 DNS mode (automatic/well-known/user defined). |
|
936 */ |
|
937 void CpWlanApAdvancedView::changeIpv6DnsMode(int state) |
|
938 { |
|
939 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_ENTRY); |
|
940 |
|
941 // Update "DNS address from server" flag |
|
942 if (state == Ipv6DnsTypeAutomatic) { |
|
943 // Automatic |
|
944 mCmConnectionMethod->setBoolAttribute( |
|
945 CMManagerShim::CmIP6DNSAddrFromServer, |
|
946 true); |
|
947 } else { |
|
948 // User defined or well-known address |
|
949 mCmConnectionMethod->setBoolAttribute( |
|
950 CMManagerShim::CmIP6DNSAddrFromServer, |
|
951 false); |
|
952 |
|
953 if (state == Ipv6DnsTypeWellKnown) { |
|
954 // Well-known address, set DNS addresses and update UI |
|
955 mCmConnectionMethod->setStringAttribute( |
|
956 CMManagerShim::CmIP6NameServer1, |
|
957 CMManagerShim::KnownIpv6NameServer1); |
|
958 mIpv6DnsAddress1->setContentWidgetData( |
|
959 "text", |
|
960 CMManagerShim::KnownIpv6NameServer1); |
|
961 mCmConnectionMethod->setStringAttribute( |
|
962 CMManagerShim::CmIP6NameServer2, |
|
963 CMManagerShim::KnownIpv6NameServer2); |
|
964 mIpv6DnsAddress2->setContentWidgetData( |
|
965 "text", |
|
966 CMManagerShim::KnownIpv6NameServer2); |
|
967 } |
|
968 } |
|
969 |
|
970 if (tryUpdate()) { |
|
971 enableIpv6DnsFields(state); |
|
972 } |
|
973 |
|
974 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_EXIT); |
|
975 } |
|
976 |
|
977 /*! |
|
978 Saves IPv6 primary DNS address to CommsDat. |
|
979 */ |
|
980 void CpWlanApAdvancedView::changeIpv6PrimaryDnsAddress() |
|
981 { |
|
982 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_ENTRY); |
|
983 |
|
984 if (validateAndSaveIpAddress( |
|
985 mIpv6DnsAddress1, |
|
986 CMManagerShim::CmIP6NameServer1, |
|
987 QAbstractSocket::IPv6Protocol)) { |
|
988 // Address saved successfully, update "DNS address from server" flag |
|
989 mCmConnectionMethod->setBoolAttribute( |
|
990 CMManagerShim::CmIP6DNSAddrFromServer, |
|
991 false); |
|
992 if (tryUpdate()) { |
|
993 // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, |
|
994 // CMManager will check secondary DNS address and in case it is a |
|
995 // valid address, move it to the primary DNS address. We need to |
|
996 // refresh the UI to make sure we are in sync. If tryUpdate() |
|
997 // fails it does the refresh automatically, so only success case |
|
998 // is handled here. |
|
999 updateIpv6Group(); |
|
1000 } |
|
1001 } |
|
1002 |
|
1003 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_EXIT); |
|
1004 } |
|
1005 |
|
1006 /*! |
|
1007 Saves IPv6 secondary DNS address to CommsDat. |
|
1008 */ |
|
1009 void CpWlanApAdvancedView::changeIpv6SecondaryDnsAddress() |
|
1010 { |
|
1011 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_ENTRY); |
|
1012 |
|
1013 if (validateAndSaveIpAddress( |
|
1014 mIpv6DnsAddress2, |
|
1015 CMManagerShim::CmIP6NameServer2, |
|
1016 QAbstractSocket::IPv6Protocol)) { |
|
1017 // Address saved successfully, update "DNS address from server" flag |
|
1018 mCmConnectionMethod->setBoolAttribute( |
|
1019 CMManagerShim::CmIP6DNSAddrFromServer, |
|
1020 false); |
|
1021 if (tryUpdate()) { |
|
1022 // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, |
|
1023 // CMManager will write the address there instead of secondary DNS |
|
1024 // address, so we need to refresh the UI to make sure we are in |
|
1025 // sync. If tryUpdate() fails it does the refresh automatically, |
|
1026 // so only success case is handled here. |
|
1027 updateIpv6Group(); |
|
1028 } |
|
1029 } |
|
1030 |
|
1031 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_EXIT); |
|
1032 } |
|
1033 |
|
1034 /*! |
|
1035 Saves proxy server address to CommsDat. |
|
1036 */ |
|
1037 void CpWlanApAdvancedView::changeProxyServer() |
|
1038 { |
|
1039 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_ENTRY); |
|
1040 |
|
1041 QString proxyServer = mProxyServer->contentWidgetData("text").toString(); |
|
1042 mCmConnectionMethod->setStringAttribute( |
|
1043 CMManagerShim::CmProxyServerName, |
|
1044 proxyServer); |
|
1045 if (tryUpdate()) { |
|
1046 // If proxy server name is empty, CMManager will also clear the |
|
1047 // proxy port. Therefore UI needs to be updated. |
|
1048 updateProxyGroup(); |
|
1049 } |
|
1050 |
|
1051 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_EXIT); |
|
1052 } |
|
1053 |
|
1054 /*! |
|
1055 Saves proxy port to CommsDat. |
|
1056 */ |
|
1057 void CpWlanApAdvancedView::changeProxyPort() |
|
1058 { |
|
1059 OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_ENTRY); |
|
1060 |
|
1061 uint proxyPort = mProxyPort->contentWidgetData("text").toInt(); |
|
1062 if (proxyPort <= 65535) { |
|
1063 if (proxyPort == 0) { |
|
1064 // Don't show zero |
|
1065 mProxyPort->setContentWidgetData("text", ""); |
|
1066 } |
|
1067 mCmConnectionMethod->setIntAttribute( |
|
1068 CMManagerShim::CmProxyPortNumber, |
|
1069 proxyPort); |
|
1070 (void)tryUpdate(); |
|
1071 } else { |
|
1072 // Inform user of invalid value |
|
1073 showMessageBox( |
|
1074 HbMessageBox::MessageTypeInformation, |
|
1075 hbTrId("txt_occ_info_invalid_input")); |
|
1076 // Restore previous setting |
|
1077 proxyPort = mCmConnectionMethod->getIntAttribute( |
|
1078 CMManagerShim::CmProxyPortNumber); |
|
1079 if (proxyPort > 0) { |
|
1080 mProxyPort->setContentWidgetData("text", QVariant(proxyPort)); |
|
1081 } else { |
|
1082 mProxyPort->setContentWidgetData("text", ""); |
|
1083 } |
|
1084 } |
|
1085 |
|
1086 OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_EXIT); |
|
1087 } |