1 /*

     2 * Copyright (c) 2010 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 * Control Panel WLAN AP advanced settings view implementation.

    16 *

    17 */

    18 

    19 // System includes

    20 #include <QHostAddress>

    21 #include <HbCheckBox>

    22 #include <HbLineEdit>

    23 #include <HbDataFormViewItem>

    24 #include <HbWidget>

    25 #include <HbEditorInterface>

    26 #include <HbUrlFilter>

    27 #include <HbInputDialog>

    28 #include <HbDataForm>

    29 #include <HbDataFormModel>

    30 #include <cmconnectionmethod_shim.h>

    31 #include <cmmanagerdefines_shim.h>

    32 #include <cpsettingformitemdata.h>

    33 

    34 // User includes

    35 #include "cpipv4filter.h"

    36 #include "cpipv6filter.h"

    37 #include "cpwlanapadvancedview.h"

    38 

    39 #include "OstTraceDefinitions.h"

    40 #ifdef OST_TRACE_COMPILER_IN_USE

    41 #include "cpwlanapadvancedviewTraces.h"

    42 #endif

    43 

    44 /*!

    45     \class CpWlanApAdvancedView

    46     \brief This class implements the WLAN AP Control Panel advanced

    47            settings view.

    48 */

    49 

    50 // External function prototypes

    51 

    52 // Local constants

    53 

    54 // ======== LOCAL FUNCTIONS ========

    55 

    56 // ======== MEMBER FUNCTIONS ========

    57 

    58 /*!

    59     Constructor.

    60 */

    61 CpWlanApAdvancedView::CpWlanApAdvancedView(

    62     CmConnectionMethodShim *cmConnectionMethod,

    63     QGraphicsItem *parent) :

    64         CpBaseSettingView(0, parent),

    65         mForm(0),

    66         mModel(0),

    67         mCmConnectionMethod(cmConnectionMethod),

    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     

    88     // Construct WLAN AP advanced settings UI

    89     mForm = new HbDataForm();

    90     this->setWidget(mForm);

    91     mModel = new HbDataFormModel(mForm);

    92     mForm->setModel(mModel);

    93 

    94     mIpv6Supported = mCmConnectionMethod->getBoolAttribute(

    95         CMManagerShim::CmIPv6Supported);

    96         

    97     // Add advanced settings groups

    98     createAdvancedSettings();

    99     

   100     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT);

   101 }

   102 

   103 /*!

   104     Destructor.

   105 */

   106 CpWlanApAdvancedView::~CpWlanApAdvancedView()

   107 {

   108     OstTraceFunctionEntry0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_ENTRY);

   109     

   110     OstTraceFunctionExit0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT);

   111 }

   112 

   113 /*!

   114     Creates all advanced settings groups.

   115 */

   116 void CpWlanApAdvancedView::createAdvancedSettings()

   117 {

   118     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_ENTRY);

   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     mIpv4Automatic->setContentWidgetData("objectName", "ipv4AutomaticCB");

   172     mIpv4Group->appendChild(mIpv4Automatic);

   173     

   174     // Phone IP address

   175     mIpv4Address = new CpSettingFormItemData(

   176         HbDataFormModelItem::TextItem,

   177         hbTrId("txt_occ_setlabel_phone_ip_address"));

   178     mForm->addConnection(

   179         mIpv4Address,

   180         SIGNAL(editingFinished()),

   181         this,

   182         SLOT(changeIpv4Address()));

   183     mIpv4Address->setContentWidgetData("objectName", "ipv4AddressEdit");

   184     mIpv4Group->appendChild(mIpv4Address);

   185     

   186     // Subnet mask

   187     mIpv4SubnetMask = new CpSettingFormItemData(

   188         HbDataFormModelItem::TextItem,

   189         hbTrId("txt_occ_setlabel_subnet_mask"));

   190     mForm->addConnection(

   191         mIpv4SubnetMask,

   192         SIGNAL(editingFinished()),

   193         this,

   194         SLOT(changeIpv4SubnetMask()));

   195     mIpv4SubnetMask->setContentWidgetData("objectName", "ipv4SubnetmaskEdit");

   196     mIpv4Group->appendChild(mIpv4SubnetMask);

   197     

   198     // Gateway

   199     mIpv4Gateway = new CpSettingFormItemData(

   200         HbDataFormModelItem::TextItem,

   201         hbTrId("txt_occ_setlabel_default_gateway"));

   202     mForm->addConnection(

   203         mIpv4Gateway,

   204         SIGNAL(editingFinished()),

   205         this,

   206         SLOT(changeIpv4Gateway()));

   207     mIpv4Gateway->setContentWidgetData("objectName", "ipv4GatewayEdit");

   208     mIpv4Group->appendChild(mIpv4Gateway);

   209     

   210     // DNS addresses

   211     // "Automatic" checkbox

   212     mIpv4DnsAutomatic = new CpSettingFormItemData(

   213         HbDataFormModelItem::CheckBoxItem,

   214         hbTrId("txt_occ_setlabel_dns_addresses"));

   215     mIpv4DnsAutomatic->setContentWidgetData(

   216         "text",

   217         hbTrId("txt_occ_setlabel_val_automatic"));

   218     mForm->addConnection(

   219         mIpv4DnsAutomatic,

   220         SIGNAL(stateChanged(int)), 

   221         this,

   222         SLOT(changeIpv4DnsMode(int)));

   223     mIpv4DnsAutomatic->setContentWidgetData("objectName", "ipv4DnsAutomaticCB");

   224     mIpv4Group->appendChild(mIpv4DnsAutomatic);

   225     

   226     // Primary DNS address

   227     mIpv4DnsAddress1 = new CpSettingFormItemData(

   228         HbDataFormModelItem::TextItem,

   229         hbTrId("txt_occ_setlabel_primary_name_server"));

   230     mForm->addConnection(

   231         mIpv4DnsAddress1,

   232         SIGNAL(editingFinished()), 

   233         this,

   234         SLOT(changeIpv4PrimaryDnsAddress()));

   235     mIpv4DnsAddress1->setContentWidgetData("objectName", "ipv4DnsAddress1Edit");

   236     mIpv4Group->appendChild(mIpv4DnsAddress1);

   237     

   238     // Secondary DNS address

   239     mIpv4DnsAddress2 = new CpSettingFormItemData(

   240         HbDataFormModelItem::TextItem,

   241         hbTrId("txt_occ_setlabel_secondary_name_server"));

   242     mForm->addConnection(

   243         mIpv4DnsAddress2,

   244         SIGNAL(editingFinished()), 

   245         this,

   246         SLOT(changeIpv4SecondaryDnsAddress()));

   247     mIpv4DnsAddress2->setContentWidgetData("objectName", "ipv4DnsAddress2Edit");

   248     mIpv4Group->appendChild(mIpv4DnsAddress2);

   249     

   250     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV4GROUP_EXIT);

   251 }

   252 

   253 /*!

   254     Reads attribute values and updates the IPv4 settings group.

   255 */

   256 void CpWlanApAdvancedView::updateIpv4Group()

   257 {

   258     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_ENTRY);

   259     

   260     // Phone IP address

   261     // "Automatic" checkbox

   262     bool ipAddressFromServer = mCmConnectionMethod->getBoolAttribute(

   263         CMManagerShim::CmIPAddrFromServer);

   264     Qt::CheckState state = Qt::Unchecked;

   265     if (ipAddressFromServer) {

   266         state = Qt::Checked;

   267     }

   268     mIpv4Automatic->setContentWidgetData("checkState", state);

   269 

   270     // Enable/disable user defined IP address fields

   271     enableIpv4AddressFields(state);

   272     

   273     // Phone IP address

   274     QString string = getIpAddress(CMManagerShim::CmIPAddress);

   275     mIpv4Address->setContentWidgetData("text", string);

   276     

   277     // Subnet mask

   278     string = getIpAddress(CMManagerShim::CmIPNetmask);

   279     mIpv4SubnetMask->setContentWidgetData("text", string);

   280     

   281     // Gateway

   282     string = getIpAddress(CMManagerShim::CmIPGateway);

   283     mIpv4Gateway->setContentWidgetData("text", string);

   284     

   285     // DNS addresses

   286     // "Automatic" checkbox

   287     state = Qt::Unchecked;

   288     if (mCmConnectionMethod->getBoolAttribute(

   289         CMManagerShim::CmIPDNSAddrFromServer)) {

   290         state = Qt::Checked;

   291     }

   292     mIpv4DnsAutomatic->setContentWidgetData("checkState", state);

   293 

   294     // Enable/disable user defined DNS address fields

   295     enableIpv4DnsFields(state);

   296     

   297     // Primary DNS address

   298     string = getIpAddress(CMManagerShim::CmIPNameServer1);

   299     mIpv4DnsAddress1->setContentWidgetData("text", string);

   300     

   301     // Secondary DNS address

   302     string = getIpAddress(CMManagerShim::CmIPNameServer2);

   303     mIpv4DnsAddress2->setContentWidgetData("text", string);

   304     

   305     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_EXIT);

   306 }

   307 

   308 /*!

   309     Creates the IPv6 settings group.

   310 */

   311 void CpWlanApAdvancedView::createIpv6Group()

   312 {

   313     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_ENTRY);

   314     

   315     // IPv6 settings group

   316     mIpv6Group = new CpSettingFormItemData(

   317         HbDataFormModelItem::GroupItem, 

   318         hbTrId("txt_occ_subhead_ipv6_settings"));

   319     mModel->appendDataFormItem(mIpv6Group);

   320     

   321     // DNS addresses

   322     // Automatic/well-known/user defined combobox

   323     mIpv6DnsAutomatic = new CpSettingFormItemData(

   324         HbDataFormModelItem::ComboBoxItem,

   325         hbTrId("txt_occ_setlabel_dns_addresses"));

   326     QStringList dnsModeList;

   327     // Order of the list must match the Ipv6DnsType enum

   328     dnsModeList

   329         << hbTrId("txt_occ_setlabel_val_automatic")

   330         << hbTrId("txt_occ_setlabel_dns_addresses_val_wellknown")

   331         << hbTrId("txt_occ_setlabel_dns_addresses_val_user_defined");

   332     mIpv6DnsAutomatic->setContentWidgetData("items", dnsModeList);

   333     mForm->addConnection(

   334         mIpv6DnsAutomatic,

   335         SIGNAL(currentIndexChanged(int)),

   336         this,

   337         SLOT(changeIpv6DnsMode(int)));

   338     mIpv6DnsAutomatic->setContentWidgetData("objectName", "ipv6DnsAutomaticCB");

   339     mIpv6Group->appendChild(mIpv6DnsAutomatic);

   340     

   341     // Primary DNS address

   342     mIpv6DnsAddress1 = new CpSettingFormItemData(

   343         HbDataFormModelItem::TextItem,

   344         hbTrId("txt_occ_setlabel_primary_name_server"));

   345     mForm->addConnection(

   346         mIpv6DnsAddress1,

   347         SIGNAL(editingFinished()),

   348         this,

   349         SLOT(changeIpv6PrimaryDnsAddress()));

   350     mIpv6DnsAddress1->setContentWidgetData("objectName", "ipv6DnsAddress1Edit");

   351     mIpv6Group->appendChild(mIpv6DnsAddress1);

   352     

   353     // Secondary DNS address

   354     mIpv6DnsAddress2 = new CpSettingFormItemData(

   355         HbDataFormModelItem::TextItem,

   356         hbTrId("txt_occ_setlabel_secondary_name_server"));

   357     mForm->addConnection(

   358         mIpv6DnsAddress2,

   359         SIGNAL(editingFinished()),

   360         this,

   361         SLOT(changeIpv6SecondaryDnsAddress()));

   362     mIpv6DnsAddress2->setContentWidgetData("objectName", "ipv6DnsAddress2Edit");

   363     mIpv6Group->appendChild(mIpv6DnsAddress2);

   364     

   365     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_EXIT);

   366 }

   367 

   368 /*!

   369     Reads attribute values and updates the IPv6 settings group.

   370 */

   371 void CpWlanApAdvancedView::updateIpv6Group()

   372 {

   373     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_ENTRY);

   374     

   375     // DNS addresses

   376     // Automatic/well-known/user defined combobox

   377     uint type = getIpv6DnsType();

   378     mIpv6DnsAutomatic->setContentWidgetData("currentIndex", type);

   379 

   380     // Enable/disable user defined DNS address fields

   381     enableIpv6DnsFields(type);

   382     

   383     // Primary DNS address

   384     QString string = getIpAddress(CMManagerShim::CmIP6NameServer1);

   385     mIpv6DnsAddress1->setContentWidgetData("text", string);

   386     

   387     // Secondary DNS address

   388     string = getIpAddress(CMManagerShim::CmIP6NameServer2);

   389     mIpv6DnsAddress2->setContentWidgetData("text", string);

   390     

   391     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_EXIT);

   392 }

   393 

   394 /*!

   395     Creates the proxy settings group.

   396 */

   397 void CpWlanApAdvancedView::createProxyGroup()

   398 {

   399     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_ENTRY);

   400     

   401     // Proxy settings group

   402     mProxyGroup = new CpSettingFormItemData(

   403         HbDataFormModelItem::GroupItem, 

   404         hbTrId("txt_occ_subhead_proxy_settings"));

   405     mModel->appendDataFormItem(mProxyGroup);

   406     

   407     // Proxy server address

   408     mProxyServer = new CpSettingFormItemData(

   409         HbDataFormModelItem::TextItem,

   410         hbTrId("txt_occ_setlabel_proxy_server_address"));

   411     mForm->addConnection(

   412         mProxyServer,

   413         SIGNAL(editingFinished()),

   414         this,

   415         SLOT(changeProxyServer()));

   416     mProxyServer->setContentWidgetData("objectName", "proxyServerEdit");

   417     mProxyGroup->appendChild(mProxyServer);

   418     

   419     // Proxy port number

   420     mProxyPort = new CpSettingFormItemData(

   421         HbDataFormModelItem::TextItem,

   422         hbTrId("txt_occ_setlabel_proxy_port_number"));

   423     mForm->addConnection(

   424         mProxyPort,

   425         SIGNAL(editingFinished()),

   426         this,

   427         SLOT(changeProxyPort()));

   428     mProxyPort->setContentWidgetData("objectName", "proxyPortEdit");

   429     mProxyGroup->appendChild(mProxyPort);

   430     

   431     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_EXIT);

   432 }

   433 

   434 /*!

   435     Reads attribute values and updates the proxy settings group.

   436 */

   437 void CpWlanApAdvancedView::updateProxyGroup()

   438 {

   439     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_ENTRY);

   440     

   441     // Proxy server address

   442     QString serverAddress = mCmConnectionMethod->getStringAttribute(

   443         CMManagerShim::CmProxyServerName);

   444     mProxyServer->setContentWidgetData("text", serverAddress);

   445     

   446     // Proxy port number

   447     uint portNumber = mCmConnectionMethod->getIntAttribute(

   448         CMManagerShim::CmProxyPortNumber);

   449     if (portNumber > 0) {

   450         mProxyPort->setContentWidgetData("text", QVariant(portNumber));

   451     } else {

   452         mProxyPort->setContentWidgetData("text", "");

   453     }

   454     

   455     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_EXIT);

   456 }

   457 

   458 /*!

   459     Reads an IP address from CommsDat with given attribute. If string is

   460     empty, a zero address (0.0.0.0 or 0:0:0:0:0:0:0:0) is returned.

   461 */

   462 QString CpWlanApAdvancedView::getIpAddress(

   463     CMManagerShim::ConnectionMethodAttribute attribute)

   464 {

   465     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_ENTRY);

   466     

   467     QString ipAddress = mCmConnectionMethod->getStringAttribute(attribute);

   468     

   469     if (ipAddress.isEmpty()) {

   470         // String is empty, return a zero address instead

   471         switch (attribute) {

   472         case CMManagerShim::CmIP6NameServer1:

   473         case CMManagerShim::CmIP6NameServer2:

   474             // IPv6 address

   475             ipAddress = CMManagerShim::DynamicIpv6Address;

   476             break;

   477         default:

   478             // IPv4 address

   479             ipAddress = CMManagerShim::UnspecifiedIpv4Address; 

   480             break;

   481         }

   482     }

   483     

   484     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_EXIT);

   485     return ipAddress;

   486 }

   487 

   488 /*!

   489     Resolves IPv6 DNS address type.

   490 */

   491 CpWlanApAdvancedView::Ipv6DnsType CpWlanApAdvancedView::getIpv6DnsType()

   492 {

   493     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_ENTRY);

   494     

   495     // Read "DNS address from server" flag

   496     bool dnsAddressFromServer = mCmConnectionMethod->getBoolAttribute(

   497         CMManagerShim::CmIP6DNSAddrFromServer);

   498     

   499     // Read IPv6 DNS addresses from CommsDat

   500     QString primaryAddress = mCmConnectionMethod->getStringAttribute(

   501         CMManagerShim::CmIP6NameServer1);

   502     QString secondaryAddress = mCmConnectionMethod->getStringAttribute(

   503         CMManagerShim::CmIP6NameServer2);

   504 

   505     // Resolve IPv6 DNS address type

   506     Ipv6DnsType type = Ipv6DnsTypeUserDefined;

   507     if (dnsAddressFromServer) {

   508         // Automatic

   509         type = Ipv6DnsTypeAutomatic;

   510     } else if (primaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer1

   511         && secondaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer2) {

   512         // Well-known IPv6 DNS addresses

   513         type = Ipv6DnsTypeWellKnown;

   514     }

   515 

   516     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_EXIT);

   517     return type;

   518 }

   519 

   520 /*!

   521     Sets IPv4 address field enabled/disabled.

   522 */

   523 void CpWlanApAdvancedView::enableIpv4AddressFields(int state)

   524 {

   525     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_ENTRY);

   526     

   527     if (state == Qt::Checked) {

   528         // Automatic, disable text field

   529         mIpv4Address->setEnabled(false);

   530         mIpv4SubnetMask->setEnabled(false);

   531         mIpv4Gateway->setEnabled(false);

   532     } else {

   533         // Manual, enable text field

   534         mIpv4Address->setEnabled(true);

   535         mIpv4SubnetMask->setEnabled(true);

   536         mIpv4Gateway->setEnabled(true);

   537     }

   538     

   539     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_EXIT);

   540 }

   541 

   542 /*!

   543     Sets IPv4 DNS address fields enabled/disabled.

   544 */

   545 void CpWlanApAdvancedView::enableIpv4DnsFields(int state)

   546 {

   547     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_ENTRY);

   548     

   549     if (state == Qt::Checked) {

   550         // Automatic, disable text fields

   551         mIpv4DnsAddress1->setEnabled(false);

   552         mIpv4DnsAddress2->setEnabled(false);

   553     } else {

   554         // Manual, enable text fields

   555         mIpv4DnsAddress1->setEnabled(true);

   556         mIpv4DnsAddress2->setEnabled(true);

   557     }

   558     

   559     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_EXIT);

   560 }

   561 

   562 /*!

   563     Sets IPv6 DNS address fields enabled/disabled.

   564 */

   565 void CpWlanApAdvancedView::enableIpv6DnsFields(int selectionIndex)

   566 {

   567     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_ENTRY);

   568     

   569     // Check combobox value

   570     if (selectionIndex == Ipv6DnsTypeUserDefined) {

   571         // User-defined, enable text fields

   572         mIpv6DnsAddress1->setEnabled(true);

   573         mIpv6DnsAddress2->setEnabled(true);

   574     } else {

   575         // Automatic or well-known, disable text fields

   576         mIpv6DnsAddress1->setEnabled(false);

   577         mIpv6DnsAddress2->setEnabled(false);

   578     }

   579     

   580     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_EXIT);

   581 }

   582 

   583 /*!

   584     Validates an IP address and saves it to CommsDat in case it was a valid

   585     address or an empty string. In case the address is not valid, an error

   586     note is shown to the user and previous setting is restored to the UI.

   587 */

   588 bool CpWlanApAdvancedView::validateAndSaveIpAddress(

   589     HbDataFormModelItem *item,

   590     CMManagerShim::ConnectionMethodAttribute attribute,

   591     QAbstractSocket::NetworkLayerProtocol protocol)

   592 {

   593     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_ENTRY);

   594     

   595     bool success = false;

   596     

   597     // Check address

   598     QString address = item->contentWidgetData("text").toString();

   599     QHostAddress hostAddress;

   600     if (hostAddress.setAddress(address)

   601         && hostAddress.protocol() == protocol) {

   602         // Proper address, convert to lower case (IPv6)

   603         address = hostAddress.toString().toLower();

   604     } else if (address.isEmpty()) {

   605         // Empty string, replace with 0.0.0.0 or 0:0:0:0:0:0:0:0

   606         if (protocol == QAbstractSocket::IPv4Protocol) {

   607             address = CMManagerShim::UnspecifiedIpv4Address;

   608         } else {

   609             address = CMManagerShim::DynamicIpv6Address;

   610         }

   611     } else {

   612         // Invalid address

   613         address.clear();

   614     }

   615 

   616     if (!address.isEmpty()) {

   617         // Save to CommsDat

   618         mCmConnectionMethod->setStringAttribute(attribute, address);

   619         if (tryUpdate()) {

   620             success = true;

   621             item->setContentWidgetData("text", address);

   622         }

   623     } else {

   624         // Inform user of invalid name

   625         showMessageBox(

   626             HbMessageBox::MessageTypeInformation,

   627             hbTrId("txt_occ_info_invalid_input"));

   628         // Restore previous setting

   629         address = getIpAddress(attribute);

   630         item->setContentWidgetData("text", address);

   631     }

   632     

   633     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_EXIT);

   634     return success;

   635 }

   636 

   637 /*!

   638     Shows message box with "OK" button using given text.

   639 */

   640 void CpWlanApAdvancedView::showMessageBox(

   641     HbMessageBox::MessageBoxType type,

   642     const QString &text)

   643 {

   644     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_ENTRY);

   645     

   646     // Create a message box

   647     mMessageBox = QSharedPointer<HbMessageBox>(new HbMessageBox(type));

   648     mMessageBox->setText(text);

   649     mMessageBox->setModal(true);

   650     mMessageBox->setTimeout(HbPopup::NoTimeout);

   651     mMessageBox->setDismissPolicy(HbPopup::NoDismiss);

   652     mMessageBox->open();

   653     

   654     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_EXIT);

   655 }

   656 

   657 /*!

   658     Tries to update connection method changes to CommsDat.

   659     Returns "true" if success, "false" if some error happened. 

   660 */

   661 bool CpWlanApAdvancedView::tryUpdate()

   662 {

   663     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_TRYUPDATE_ENTRY);

   664     

   665     // Try update

   666     bool success = true;

   667     try {

   668         mCmConnectionMethod->update();

   669     }

   670     catch (const std::exception&) {

   671         // Handle error

   672         handleUpdateError();

   673         

   674         success = false;

   675     }

   676 

   677     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_TRYUPDATE_EXIT);

   678     return success;

   679 }

   680 

   681 /*!

   682     Handles failed CommsDat update.

   683  */

   684 void CpWlanApAdvancedView::handleUpdateError()

   685 {

   686     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_ENTRY);

   687     

   688     // Show error note to user

   689     showMessageBox(

   690         HbMessageBox::MessageTypeWarning,

   691         hbTrId("txt_occ_info_unable_to_save_setting"));

   692     // Reload settings from CommsDat and update UI

   693     try {

   694         mCmConnectionMethod->refresh();

   695     }

   696     catch (const std::exception&) {

   697         // Ignore error from refresh. Most likely this will not happen, but

   698         // if it does, there isn't very much we can do.

   699         OstTrace0(

   700             TRACE_ERROR,

   701             CPWLANAPPADVANCEDVIEW_HANDLEUPDATEERROR,

   702             "Refresh failed");

   703     };

   704     updateIpv4Group();

   705     if (mIpv6Supported) {

   706         updateIpv6Group();

   707     }

   708     updateProxyGroup();

   709     

   710     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_EXIT);

   711 }

   712 

   713 /*!

   714     Initializes all settings groups.

   715 */

   716 void CpWlanApAdvancedView::setEditorPreferences(const QModelIndex index)

   717 {

   718     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_ENTRY);

   719     

   720     HbDataFormViewItem *viewItem = qobject_cast<HbDataFormViewItem *>

   721         (mForm->itemByIndex(index));

   722     HbDataFormModelItem *modelItem = mModel->itemFromIndex(index);

   723 

   724     if (modelItem == mIpv4Address

   725         || modelItem == mIpv4SubnetMask

   726         || modelItem == mIpv4Gateway

   727         || modelItem == mIpv4DnsAddress1

   728         || modelItem == mIpv4DnsAddress2

   729         || modelItem == mIpv6DnsAddress1

   730         || modelItem == mIpv6DnsAddress2

   731         || modelItem == mProxyServer

   732         || modelItem == mProxyPort) {

   733         // HbLineEdit items, get editor and editor interface

   734         HbLineEdit *edit = qobject_cast<HbLineEdit *>

   735             (viewItem->dataItemContentWidget());

   736         HbEditorInterface editorInterface(edit);

   737 

   738         if (modelItem == mIpv4Address

   739             || modelItem == mIpv4SubnetMask

   740             || modelItem == mIpv4Gateway

   741             || modelItem == mIpv4DnsAddress1

   742             || modelItem == mIpv4DnsAddress2) {

   743             // IPv4 IP address

   744             editorInterface.setMode(HbInputModeNumeric);

   745             editorInterface.setFilter(CpIpv4Filter::instance());

   746             edit->setMaxLength(CMManagerShim::CmIP4AddressLength);

   747         } else if (modelItem == mIpv6DnsAddress1

   748             || modelItem == mIpv6DnsAddress2) {

   749             // IPv6 IP address

   750             editorInterface.setInputConstraints(

   751                 HbEditorConstraintLatinAlphabetOnly);

   752             editorInterface.setFilter(CpIpv6Filter::instance());

   753             edit->setInputMethodHints(

   754                 Qt::ImhNoPredictiveText

   755                 | Qt::ImhPreferLowercase);

   756             edit->setMaxLength(CMManagerShim::CmIP6NameServerLength);

   757         } else if (modelItem == mProxyServer) {                

   758             // Proxy server address

   759             editorInterface.setMode(HbInputModeNone);

   760             editorInterface.setInputConstraints(

   761                 HbEditorConstraintLatinAlphabetOnly);

   762             editorInterface.setFilter(HbUrlFilter::instance());

   763             editorInterface.setEditorClass(HbInputEditorClassUrl);

   764             editorInterface.setDigitType(HbDigitTypeNone);

   765             edit->setInputMethodHints(

   766                 Qt::ImhNoPredictiveText

   767                 | Qt::ImhPreferLowercase);

   768             edit->setMaxLength(CMManagerShim::CmProxyServerNameLength);

   769         } else { /* mProxyPort */                

   770             // Proxy port number

   771             editorInterface.setMode(HbInputModeNumeric);

   772             edit->setInputMethodHints(Qt::ImhDigitsOnly);

   773             edit->setMaxLength(CMManagerShim::CmProxyPortNumberLength);

   774         }

   775     }

   776     

   777     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_EXIT);

   778 }

   779 

   780 /*!

   781     Handles change to IPv4 address mode (automatic/user defined).

   782 */

   783 void CpWlanApAdvancedView::changeIpv4AddressMode(int state)

   784 {

   785     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_ENTRY);

   786     

   787     bool ipv4AddressFromServer;

   788     if (state == Qt::Checked) {

   789         ipv4AddressFromServer = true;

   790     } else {

   791         ipv4AddressFromServer = false;

   792     }

   793     

   794     if (!ipv4AddressFromServer

   795         && getIpAddress(CMManagerShim::CmIPAddress) ==

   796             CMManagerShim::UnspecifiedIpv4Address) {

   797         // User defined IP address selected, but no valid address is stored.

   798         // Just enable the UI IP editors, because CMManager will update the

   799         // "IP address from server" flag by itself when a valid IP address

   800         // is stored.

   801         enableIpv4AddressFields(state);

   802     } else {

   803         // Save setting to CommsDat

   804         mCmConnectionMethod->setBoolAttribute(

   805             CMManagerShim::CmIPAddrFromServer,

   806             ipv4AddressFromServer);

   807         if (tryUpdate()) {

   808             enableIpv4AddressFields(state);

   809         }

   810     }

   811     

   812     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_EXIT);

   813 }

   814 

   815 /*!

   816     Saves IPv4 address to CommsDat.

   817 */

   818 void CpWlanApAdvancedView::changeIpv4Address()

   819 {

   820     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_ENTRY);

   821     

   822     if (validateAndSaveIpAddress(

   823         mIpv4Address,

   824         CMManagerShim::CmIPAddress,

   825         QAbstractSocket::IPv4Protocol)) {

   826         // In case the IP address is empty or 0.0.0.0, CMManager changes the

   827         // "IP address from server" flag to true. We need to refresh the UI to

   828         // make sure we are in sync.

   829         updateIpv4Group();

   830     }

   831 

   832     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_EXIT);

   833 }

   834 

   835 /*!

   836     Saves IPv4 subnet mask to CommsDat.

   837 */

   838 void CpWlanApAdvancedView::changeIpv4SubnetMask()

   839 {

   840     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_ENTRY);

   841     

   842     (void)validateAndSaveIpAddress(

   843         mIpv4SubnetMask,

   844         CMManagerShim::CmIPNetmask,

   845         QAbstractSocket::IPv4Protocol);

   846     

   847     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_EXIT);

   848 }

   849 

   850 /*!

   851     Saves IPv4 gateway to CommsDat.

   852 */

   853 void CpWlanApAdvancedView::changeIpv4Gateway()

   854 {

   855     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_ENTRY);

   856     

   857     (void)validateAndSaveIpAddress(

   858         mIpv4Gateway,

   859         CMManagerShim::CmIPGateway,

   860         QAbstractSocket::IPv4Protocol);

   861 

   862     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_EXIT);

   863 }

   864 

   865 /*!

   866     Handles change to IPv4 DNS mode (automatic/user defined).

   867 */

   868 void CpWlanApAdvancedView::changeIpv4DnsMode(int state)

   869 {

   870     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_ENTRY);

   871     

   872     bool dnsAddressFromServer;

   873     if (state == Qt::Checked) {

   874         dnsAddressFromServer = true;

   875     } else {

   876         dnsAddressFromServer = false;

   877     }

   878     // Save setting to CommsDat

   879     mCmConnectionMethod->setBoolAttribute(

   880         CMManagerShim::CmIPDNSAddrFromServer,

   881         dnsAddressFromServer);

   882     if (tryUpdate()) {

   883         enableIpv4DnsFields(state);

   884     }

   885     

   886     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_EXIT);

   887 }

   888 

   889 /*!

   890     Saves IPv4 primary DNS address to CommsDat.

   891 */

   892 void CpWlanApAdvancedView::changeIpv4PrimaryDnsAddress()

   893 {

   894     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_ENTRY);

   895     

   896     if (validateAndSaveIpAddress(

   897         mIpv4DnsAddress1,

   898         CMManagerShim::CmIPNameServer1,

   899         QAbstractSocket::IPv4Protocol)) {

   900         // Address saved successfully, update "DNS address from server" flag

   901         mCmConnectionMethod->setBoolAttribute(

   902             CMManagerShim::CmIPDNSAddrFromServer,

   903             false);

   904         if (tryUpdate()) {

   905             // In case primary DNS address is empty or 0.0.0.0, CMManager will

   906             // check secondary DNS address and in case it is a valid address,

   907             // move it to the primary DNS address. We need to refresh the

   908             // UI to make sure we are in sync. If tryUpdate() fails it does

   909             // the refresh automatically, so only success case is handled

   910             // here.

   911             updateIpv4Group();            

   912         }

   913     }

   914     

   915     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_EXIT);

   916 }

   917 

   918 /*!

   919     Saves IPv4 secondary DNS address to CommsDat.

   920 */

   921 void CpWlanApAdvancedView::changeIpv4SecondaryDnsAddress()

   922 {

   923     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_ENTRY);

   924     

   925     if (validateAndSaveIpAddress(

   926         mIpv4DnsAddress2,

   927         CMManagerShim::CmIPNameServer2,

   928         QAbstractSocket::IPv4Protocol)) {

   929         // Address saved successfully, update "DNS address from server" flag

   930         mCmConnectionMethod->setBoolAttribute(

   931             CMManagerShim::CmIPDNSAddrFromServer,

   932             false);

   933         if (tryUpdate()) {

   934             // In case primary DNS address is empty or 0.0.0.0, CMManager will

   935             // write the address there instead of secondary DNS address, so we

   936             // need to refresh the UI to make sure we are in sync. If

   937             // tryUpdate() fails it does the refresh automatically, so only

   938             // success case is handled here.

   939             updateIpv4Group();

   940         }

   941     }

   942     

   943     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_EXIT);

   944 }

   945 

   946 /*!

   947     Handles change to IPv6 DNS mode (automatic/well-known/user defined).

   948 */

   949 void CpWlanApAdvancedView::changeIpv6DnsMode(int state)

   950 {

   951     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_ENTRY);

   952     

   953     // Update "DNS address from server" flag

   954     if (state == Ipv6DnsTypeAutomatic) {

   955         // Automatic

   956         mCmConnectionMethod->setBoolAttribute(

   957             CMManagerShim::CmIP6DNSAddrFromServer,

   958             true);

   959     } else {

   960         // User defined or well-known address

   961         mCmConnectionMethod->setBoolAttribute(

   962             CMManagerShim::CmIP6DNSAddrFromServer,

   963             false);

   964         

   965         if (state == Ipv6DnsTypeWellKnown) {

   966             // Well-known address, set DNS addresses and update UI

   967             mCmConnectionMethod->setStringAttribute(

   968                 CMManagerShim::CmIP6NameServer1,

   969                 CMManagerShim::KnownIpv6NameServer1);

   970             mIpv6DnsAddress1->setContentWidgetData(

   971                 "text",

   972                 CMManagerShim::KnownIpv6NameServer1);

   973             mCmConnectionMethod->setStringAttribute(

   974                 CMManagerShim::CmIP6NameServer2,

   975                 CMManagerShim::KnownIpv6NameServer2);

   976             mIpv6DnsAddress2->setContentWidgetData(

   977                 "text",

   978                 CMManagerShim::KnownIpv6NameServer2);        

   979         }

   980     }

   981 

   982     if (tryUpdate()) {

   983         enableIpv6DnsFields(state);

   984     }

   985     

   986     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_EXIT);

   987 }

   988 

   989 /*!

   990     Saves IPv6 primary DNS address to CommsDat.

   991 */

   992 void CpWlanApAdvancedView::changeIpv6PrimaryDnsAddress()

   993 {

   994     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_ENTRY);

   995     

   996     if (validateAndSaveIpAddress(

   997         mIpv6DnsAddress1,

   998         CMManagerShim::CmIP6NameServer1,

   999         QAbstractSocket::IPv6Protocol)) {

  1000         // Address saved successfully, update "DNS address from server" flag

  1001         mCmConnectionMethod->setBoolAttribute(

  1002             CMManagerShim::CmIP6DNSAddrFromServer,

  1003             false);

  1004         if (tryUpdate()) {

  1005             // In case primary DNS address is empty or 0:0:0:0:0:0:0:0,

  1006             // CMManager will check secondary DNS address and in case it is a

  1007             // valid address, move it to the primary DNS address. We need to

  1008             // refresh the UI to make sure we are in sync. If tryUpdate()

  1009             // fails it does the refresh automatically, so only success case

  1010             // is handled here.

  1011             updateIpv6Group();            

  1012         }

  1013     }

  1014     

  1015     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_EXIT);

  1016 }

  1017 

  1018 /*!

  1019     Saves IPv6 secondary DNS address to CommsDat.

  1020 */

  1021 void CpWlanApAdvancedView::changeIpv6SecondaryDnsAddress()

  1022 {

  1023     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_ENTRY);

  1024     

  1025     if (validateAndSaveIpAddress(

  1026         mIpv6DnsAddress2,

  1027         CMManagerShim::CmIP6NameServer2,

  1028         QAbstractSocket::IPv6Protocol)) {

  1029         // Address saved successfully, update "DNS address from server" flag

  1030         mCmConnectionMethod->setBoolAttribute(

  1031             CMManagerShim::CmIP6DNSAddrFromServer,

  1032             false);

  1033         if (tryUpdate()) {

  1034             // In case primary DNS address is empty or 0:0:0:0:0:0:0:0,

  1035             // CMManager will write the address there instead of secondary DNS

  1036             // address, so we need to refresh the UI to make sure we are in

  1037             // sync. If tryUpdate() fails it does the refresh automatically,

  1038             // so only success case is handled here.

  1039             updateIpv6Group();

  1040         }

  1041     }

  1042     

  1043     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_EXIT);

  1044 }

  1045 

  1046 /*!

  1047     Saves proxy server address to CommsDat.

  1048 */

  1049 void CpWlanApAdvancedView::changeProxyServer()

  1050 {

  1051     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_ENTRY);

  1052     

  1053     QString proxyServer = mProxyServer->contentWidgetData("text").toString();

  1054     mCmConnectionMethod->setStringAttribute(

  1055         CMManagerShim::CmProxyServerName,

  1056         proxyServer);

  1057     if (tryUpdate()) {

  1058         // If proxy server name is empty, CMManager will also clear the

  1059         // proxy port. Therefore UI needs to be updated.

  1060         updateProxyGroup();

  1061     }

  1062     

  1063     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_EXIT);

  1064 }

  1065 

  1066 /*!

  1067     Saves proxy port to CommsDat.

  1068 */

  1069 void CpWlanApAdvancedView::changeProxyPort()

  1070 {

  1071     OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_ENTRY);

  1072     

  1073     uint proxyPort = mProxyPort->contentWidgetData("text").toInt();

  1074     if (proxyPort <= 65535) {

  1075         if (proxyPort == 0) {

  1076             // Don't show zero

  1077             mProxyPort->setContentWidgetData("text", "");

  1078         }

  1079         mCmConnectionMethod->setIntAttribute(

  1080             CMManagerShim::CmProxyPortNumber,

  1081             proxyPort);

  1082         (void)tryUpdate();

  1083     } else {

  1084         // Inform user of invalid value

  1085         showMessageBox(

  1086             HbMessageBox::MessageTypeInformation,

  1087             hbTrId("txt_occ_info_invalid_input"));

  1088         // Restore previous setting

  1089         proxyPort = mCmConnectionMethod->getIntAttribute(

  1090             CMManagerShim::CmProxyPortNumber);

  1091         if (proxyPort > 0) {

  1092             mProxyPort->setContentWidgetData("text", QVariant(proxyPort));

  1093         } else {

  1094             mProxyPort->setContentWidgetData("text", "");

  1095         }

  1096     }

  1097     

  1098     OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_EXIT);

  1099 }