diff -r 1f1fcd7e941c -r 8dde790cab74 cmmanager/cpwlanapplugin/src/cpwlanapadvancedview.cpp --- a/cmmanager/cpwlanapplugin/src/cpwlanapadvancedview.cpp Thu May 13 23:17:48 2010 +0300 +++ b/cmmanager/cpwlanapplugin/src/cpwlanapadvancedview.cpp Fri May 14 10:52:16 2010 +0300 @@ -11,20 +11,36 @@ * * Contributors: * -* Description: +* Description: * Control Panel WLAN AP advanced settings view implementation. * */ // System includes +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include +#include #include // User includes +#include "cpipv4filter.h" +#include "cpipv6filter.h" #include "cpwlanapadvancedview.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "cpwlanapadvancedviewTraces.h" +#endif + /*! \class CpWlanApAdvancedView \brief This class implements the WLAN AP Control Panel advanced @@ -48,16 +64,40 @@ CpBaseSettingView(0, parent), mForm(0), mModel(0), - mCmConnectionMethod(cmConnectionMethod) + mCmConnectionMethod(cmConnectionMethod), + mIpv4Group(0), + mIpv4Automatic(0), + mIpv4Address(0), + mIpv4SubnetMask(0), + mIpv4Gateway(0), + mIpv4DnsAutomatic(0), + mIpv4DnsAddress1(0), + mIpv4DnsAddress2(0), + mIpv6Group(0), + mIpv6DnsAutomatic(0), + mIpv6DnsAddress1(0), + mIpv6DnsAddress2(0), + mProxyGroup(0), + mProxyServer(0), + mProxyPort(0), + mMessageBox(0), + mIpv6Supported(false) { + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_ENTRY); + // Construct WLAN AP advanced settings UI mForm = new HbDataForm(); this->setWidget(mForm); mModel = new HbDataFormModel(mForm); mForm->setModel(mModel); + mIpv6Supported = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIPv6Supported); + // Add advanced settings groups createAdvancedSettings(); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT); } /*! @@ -65,6 +105,9 @@ */ CpWlanApAdvancedView::~CpWlanApAdvancedView() { + OstTraceFunctionEntry0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_ENTRY); + + OstTraceFunctionExit0(DUP1_CPWLANAPADVANCEDVIEW_CPWLANAPADVANCEDVIEW_EXIT); } /*! @@ -72,5 +115,973 @@ */ void CpWlanApAdvancedView::createAdvancedSettings() { - // TODO: Implement the advanced settings view. + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_ENTRY); + + // Create settings groups + createIpv4Group(); + if (mIpv6Supported) { + createIpv6Group(); + } + createProxyGroup(); + + // Read values and update UI + updateIpv4Group(); + if (mIpv6Supported) { + updateIpv6Group(); + } + updateProxyGroup(); + + // Connect signal to initialize settings item widgets + bool status = connect( + mForm, + SIGNAL(itemShown(const QModelIndex)), + this, + SLOT(setEditorPreferences(const QModelIndex))); + Q_ASSERT(status); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEADVANCEDSETTINGS_EXIT); +} + +/*! + Creates the IPv4 settings group. +*/ +void CpWlanApAdvancedView::createIpv4Group() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEIPV4GROUP_ENTRY); + + // IPv4 settings group + mIpv4Group = new CpSettingFormItemData( + HbDataFormModelItem::GroupItem, + hbTrId("txt_occ_subhead_ipv4_settings")); + mModel->appendDataFormItem(mIpv4Group); + + // Phone IP address + // "Automatic" checkbox + mIpv4Automatic = new CpSettingFormItemData( + HbDataFormModelItem::CheckBoxItem, + hbTrId("txt_occ_setlabel_phone_ip_address")); + mIpv4Automatic->setContentWidgetData( + "text", + hbTrId("txt_occ_setlabel_val_automatic")); + mForm->addConnection( + mIpv4Automatic, + SIGNAL(stateChanged(int)), + this, + SLOT(changeIpv4AddressMode(int))); + mIpv4Group->appendChild(mIpv4Automatic); + + // Phone IP address + mIpv4Address = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_phone_ip_address")); + mForm->addConnection( + mIpv4Address, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4Address())); + mIpv4Group->appendChild(mIpv4Address); + + // Subnet mask + mIpv4SubnetMask = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_subnet_mask")); + mForm->addConnection( + mIpv4SubnetMask, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4SubnetMask())); + mIpv4Group->appendChild(mIpv4SubnetMask); + + // Gateway + mIpv4Gateway = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_default_gateway")); + mForm->addConnection( + mIpv4Gateway, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4Gateway())); + mIpv4Group->appendChild(mIpv4Gateway); + + // DNS addresses + // "Automatic" checkbox + mIpv4DnsAutomatic = new CpSettingFormItemData( + HbDataFormModelItem::CheckBoxItem, + hbTrId("txt_occ_setlabel_dns_addresses")); + mIpv4DnsAutomatic->setContentWidgetData( + "text", + hbTrId("txt_occ_setlabel_val_automatic")); + mForm->addConnection( + mIpv4DnsAutomatic, + SIGNAL(stateChanged(int)), + this, + SLOT(changeIpv4DnsMode(int))); + mIpv4Group->appendChild(mIpv4DnsAutomatic); + + // Primary DNS address + mIpv4DnsAddress1 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_primary_name_server")); + mForm->addConnection( + mIpv4DnsAddress1, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4PrimaryDnsAddress())); + mIpv4Group->appendChild(mIpv4DnsAddress1); + + // Secondary DNS address + mIpv4DnsAddress2 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_secondary_name_server")); + mForm->addConnection( + mIpv4DnsAddress2, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv4SecondaryDnsAddress())); + mIpv4Group->appendChild(mIpv4DnsAddress2); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV4GROUP_EXIT); +} + +/*! + Reads attribute values and updates the IPv4 settings group. +*/ +void CpWlanApAdvancedView::updateIpv4Group() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_ENTRY); + + // Phone IP address + // "Automatic" checkbox + bool ipAddressFromServer = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIPAddrFromServer); + Qt::CheckState state = Qt::Unchecked; + if (ipAddressFromServer) { + state = Qt::Checked; + } + mIpv4Automatic->setContentWidgetData("checkState", state); + + // Enable/disable user defined IP address fields + enableIpv4AddressFields(state); + + // Phone IP address + QString string = getIpAddress(CMManagerShim::CmIPAddress); + mIpv4Address->setContentWidgetData("text", string); + + // Subnet mask + string = getIpAddress(CMManagerShim::CmIPNetmask); + mIpv4SubnetMask->setContentWidgetData("text", string); + + // Gateway + string = getIpAddress(CMManagerShim::CmIPGateway); + mIpv4Gateway->setContentWidgetData("text", string); + + // DNS addresses + // "Automatic" checkbox + state = Qt::Unchecked; + if (mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer)) { + state = Qt::Checked; + } + mIpv4DnsAutomatic->setContentWidgetData("checkState", state); + + // Enable/disable user defined DNS address fields + enableIpv4DnsFields(state); + + // Primary DNS address + string = getIpAddress(CMManagerShim::CmIPNameServer1); + mIpv4DnsAddress1->setContentWidgetData("text", string); + + // Secondary DNS address + string = getIpAddress(CMManagerShim::CmIPNameServer2); + mIpv4DnsAddress2->setContentWidgetData("text", string); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV4GROUP_EXIT); +} + +/*! + Creates the IPv6 settings group. +*/ +void CpWlanApAdvancedView::createIpv6Group() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_ENTRY); + + // IPv6 settings group + mIpv6Group = new CpSettingFormItemData( + HbDataFormModelItem::GroupItem, + hbTrId("txt_occ_subhead_ipv6_settings")); + mModel->appendDataFormItem(mIpv6Group); + + // DNS addresses + // Automatic/well-known/user defined combobox + mIpv6DnsAutomatic = new CpSettingFormItemData( + HbDataFormModelItem::ComboBoxItem, + hbTrId("txt_occ_setlabel_dns_addresses")); + QStringList dnsModeList; + // Order of the list must match the Ipv6DnsType enum + dnsModeList + << hbTrId("txt_occ_setlabel_val_automatic") + << hbTrId("txt_occ_setlabel_dns_addresses_val_wellknown") + << hbTrId("txt_occ_setlabel_dns_addresses_val_user_defined"); + mIpv6DnsAutomatic->setContentWidgetData("items", dnsModeList); + mForm->addConnection( + mIpv6DnsAutomatic, + SIGNAL(currentIndexChanged(int)), + this, + SLOT(changeIpv6DnsMode(int))); + mIpv6Group->appendChild(mIpv6DnsAutomatic); + + // Primary DNS address + mIpv6DnsAddress1 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_primary_name_server")); + mForm->addConnection( + mIpv6DnsAddress1, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv6PrimaryDnsAddress())); + mIpv6Group->appendChild(mIpv6DnsAddress1); + + // Secondary DNS address + mIpv6DnsAddress2 = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_secondary_name_server")); + mForm->addConnection( + mIpv6DnsAddress2, + SIGNAL(editingFinished()), + this, + SLOT(changeIpv6SecondaryDnsAddress())); + mIpv6Group->appendChild(mIpv6DnsAddress2); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEIPV6GROUP_EXIT); +} + +/*! + Reads attribute values and updates the IPv6 settings group. +*/ +void CpWlanApAdvancedView::updateIpv6Group() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_ENTRY); + + // DNS addresses + // Automatic/well-known/user defined combobox + uint type = getIpv6DnsType(); + mIpv6DnsAutomatic->setContentWidgetData("currentIndex", type); + + // Enable/disable user defined DNS address fields + enableIpv6DnsFields(type); + + // Primary DNS address + QString string = getIpAddress(CMManagerShim::CmIP6NameServer1); + mIpv6DnsAddress1->setContentWidgetData("text", string); + + // Secondary DNS address + string = getIpAddress(CMManagerShim::CmIP6NameServer2); + mIpv6DnsAddress2->setContentWidgetData("text", string); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEIPV6GROUP_EXIT); +} + +/*! + Creates the proxy settings group. +*/ +void CpWlanApAdvancedView::createProxyGroup() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_ENTRY); + + // Proxy settings group + mProxyGroup = new CpSettingFormItemData( + HbDataFormModelItem::GroupItem, + hbTrId("txt_occ_subhead_proxy_settings")); + mModel->appendDataFormItem(mProxyGroup); + + // Proxy server address + mProxyServer = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_proxy_server_address")); + mForm->addConnection( + mProxyServer, + SIGNAL(editingFinished()), + this, + SLOT(changeProxyServer())); + mProxyGroup->appendChild(mProxyServer); + + // Proxy port number + mProxyPort = new CpSettingFormItemData( + HbDataFormModelItem::TextItem, + hbTrId("txt_occ_setlabel_proxy_port_number")); + mForm->addConnection( + mProxyPort, + SIGNAL(editingFinished()), + this, + SLOT(changeProxyPort())); + mProxyGroup->appendChild(mProxyPort); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CREATEPROXYGROUP_EXIT); +} + +/*! + Reads attribute values and updates the proxy settings group. +*/ +void CpWlanApAdvancedView::updateProxyGroup() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_ENTRY); + + // Proxy server address + QString serverAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmProxyServerName); + mProxyServer->setContentWidgetData("text", serverAddress); + + // Proxy port number + uint portNumber = mCmConnectionMethod->getIntAttribute( + CMManagerShim::CmProxyPortNumber); + if (portNumber > 0) { + mProxyPort->setContentWidgetData("text", QVariant(portNumber)); + } else { + mProxyPort->setContentWidgetData("text", ""); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_UPDATEPROXYGROUP_EXIT); +} + +/*! + Reads an IP address from CommsDat with given attribute. If string is + empty, a zero address (0.0.0.0 or 0:0:0:0:0:0:0:0) is returned. +*/ +QString CpWlanApAdvancedView::getIpAddress( + CMManagerShim::ConnectionMethodAttribute attribute) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_ENTRY); + + QString ipAddress = mCmConnectionMethod->getStringAttribute(attribute); + + if (ipAddress.isEmpty()) { + // String is empty, return a zero address instead + switch (attribute) { + case CMManagerShim::CmIP6NameServer1: + case CMManagerShim::CmIP6NameServer2: + // IPv6 address + ipAddress = CMManagerShim::DynamicIpv6Address; + break; + default: + // IPv4 address + ipAddress = CMManagerShim::UnspecifiedIpv4Address; + break; + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPADDRESS_EXIT); + return ipAddress; +} + +/*! + Resolves IPv6 DNS address type. +*/ +CpWlanApAdvancedView::Ipv6DnsType CpWlanApAdvancedView::getIpv6DnsType() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_ENTRY); + + // Read "DNS address from server" flag + bool dnsAddressFromServer = mCmConnectionMethod->getBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer); + + // Read IPv6 DNS addresses from CommsDat + QString primaryAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmIP6NameServer1); + QString secondaryAddress = mCmConnectionMethod->getStringAttribute( + CMManagerShim::CmIP6NameServer2); + + // Resolve IPv6 DNS address type + Ipv6DnsType type = Ipv6DnsTypeUserDefined; + if (dnsAddressFromServer) { + // Automatic + type = Ipv6DnsTypeAutomatic; + } else if (primaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer1 + && secondaryAddress.toLower() == CMManagerShim::KnownIpv6NameServer2) { + // Well-known IPv6 DNS addresses + type = Ipv6DnsTypeWellKnown; + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_GETIPV6DNSTYPE_EXIT); + return type; +} + +/*! + Sets IPv4 address field enabled/disabled. +*/ +void CpWlanApAdvancedView::enableIpv4AddressFields(int state) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_ENTRY); + + if (state == Qt::Checked) { + // Automatic, disable text field + mIpv4Address->setEnabled(false); + mIpv4SubnetMask->setEnabled(false); + mIpv4Gateway->setEnabled(false); + } else { + // Manual, enable text field + mIpv4Address->setEnabled(true); + mIpv4SubnetMask->setEnabled(true); + mIpv4Gateway->setEnabled(true); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4ADDRESSFIELDS_EXIT); +} + +/*! + Sets IPv4 DNS address fields enabled/disabled. +*/ +void CpWlanApAdvancedView::enableIpv4DnsFields(int state) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_ENTRY); + + if (state == Qt::Checked) { + // Automatic, disable text fields + mIpv4DnsAddress1->setEnabled(false); + mIpv4DnsAddress2->setEnabled(false); + } else { + // Manual, enable text fields + mIpv4DnsAddress1->setEnabled(true); + mIpv4DnsAddress2->setEnabled(true); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV4DNSFIELDS_EXIT); +} + +/*! + Sets IPv6 DNS address fields enabled/disabled. +*/ +void CpWlanApAdvancedView::enableIpv6DnsFields(int selectionIndex) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_ENTRY); + + // Check combobox value + if (selectionIndex == Ipv6DnsTypeUserDefined) { + // User-defined, enable text fields + mIpv6DnsAddress1->setEnabled(true); + mIpv6DnsAddress2->setEnabled(true); + } else { + // Automatic or well-known, disable text fields + mIpv6DnsAddress1->setEnabled(false); + mIpv6DnsAddress2->setEnabled(false); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_ENABLEIPV6DNSFIELDS_EXIT); } + +/*! + Validates an IP address and saves it to CommsDat in case it was a valid + address or an empty string. In case the address is not valid, an error + note is shown to the user and previous setting is restored to the UI. +*/ +bool CpWlanApAdvancedView::validateAndSaveIpAddress( + HbDataFormModelItem *item, + CMManagerShim::ConnectionMethodAttribute attribute, + QAbstractSocket::NetworkLayerProtocol protocol) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_ENTRY); + + bool success = false; + + // Check address + QString address = item->contentWidgetData("text").toString(); + QHostAddress hostAddress; + if (hostAddress.setAddress(address) + && hostAddress.protocol() == protocol) { + // Proper address, convert to lower case (IPv6) + address = hostAddress.toString().toLower(); + } else if (address.isEmpty()) { + // Empty string, replace with 0.0.0.0 or 0:0:0:0:0:0:0:0 + if (protocol == QAbstractSocket::IPv4Protocol) { + address = CMManagerShim::UnspecifiedIpv4Address; + } else { + address = CMManagerShim::DynamicIpv6Address; + } + } else { + // Invalid address + address.clear(); + } + + if (!address.isEmpty()) { + // Save to CommsDat + mCmConnectionMethod->setStringAttribute(attribute, address); + if (tryUpdate()) { + success = true; + item->setContentWidgetData("text", address); + } + } else { + // Inform user of invalid name + showMessageBox( + HbMessageBox::MessageTypeInformation, + hbTrId("txt_occ_info_invalid_input")); + // Restore previous setting + address = getIpAddress(attribute); + item->setContentWidgetData("text", address); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_VALIDATEANDSAVEIPADDRESS_EXIT); + return success; +} + +/*! + Shows message box with "OK" button using given text. +*/ +void CpWlanApAdvancedView::showMessageBox( + HbMessageBox::MessageBoxType type, + const QString &text) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_ENTRY); + + // Create a message box + mMessageBox = QSharedPointer(new HbMessageBox(type)); + mMessageBox->setText(text); + mMessageBox->setModal(true); + mMessageBox->setTimeout(HbPopup::NoTimeout); + mMessageBox->setDismissPolicy(HbPopup::NoDismiss); + mMessageBox->open(); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SHOWMESSAGEBOX_EXIT); +} + +/*! + Tries to update connection method changes to CommsDat. + Returns "true" if success, "false" if some error happened. +*/ +bool CpWlanApAdvancedView::tryUpdate() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_TRYUPDATE_ENTRY); + + // Try update + bool success = true; + try { + mCmConnectionMethod->update(); + } + catch (const std::exception&) { + // Handle error + handleUpdateError(); + + success = false; + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_TRYUPDATE_EXIT); + return success; +} + +/*! + Handles failed CommsDat update. + */ +void CpWlanApAdvancedView::handleUpdateError() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_ENTRY); + + // Show error note to user + showMessageBox( + HbMessageBox::MessageTypeWarning, + hbTrId("txt_occ_info_unable_to_save_setting")); + // Reload settings from CommsDat and update UI + try { + mCmConnectionMethod->refresh(); + } + catch (const std::exception&) { + // Ignore error from refresh. Most likely this will not happen, but + // if it does, there isn't very much we can do. + OstTrace0( + TRACE_ERROR, + CPWLANAPPADVANCEDVIEW_HANDLEUPDATEERROR, + "Refresh failed"); + }; + updateIpv4Group(); + if (mIpv6Supported) { + updateIpv6Group(); + } + updateProxyGroup(); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_HANDLEUPDATEERROR_EXIT); +} + +/*! + Initializes all settings groups. +*/ +void CpWlanApAdvancedView::setEditorPreferences(const QModelIndex index) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_ENTRY); + + HbDataFormViewItem *viewItem = qobject_cast + (mForm->itemByIndex(index)); + HbDataFormModelItem *modelItem = mModel->itemFromIndex(index); + + if (modelItem == mIpv4Address + || modelItem == mIpv4SubnetMask + || modelItem == mIpv4Gateway + || modelItem == mIpv4DnsAddress1 + || modelItem == mIpv4DnsAddress2 + || modelItem == mIpv6DnsAddress1 + || modelItem == mIpv6DnsAddress2 + || modelItem == mProxyServer + || modelItem == mProxyPort) { + // HbLineEdit items, get editor and editor interface + HbLineEdit *edit = qobject_cast + (viewItem->dataItemContentWidget()); + HbEditorInterface editorInterface(edit); + + if (modelItem == mIpv4Address + || modelItem == mIpv4SubnetMask + || modelItem == mIpv4Gateway + || modelItem == mIpv4DnsAddress1 + || modelItem == mIpv4DnsAddress2) { + // IPv4 IP address + editorInterface.setMode(HbInputModeNumeric); + editorInterface.setFilter(CpIpv4Filter::instance()); + edit->setMaxLength(CMManagerShim::CmIP4AddressLength); + } else if (modelItem == mIpv6DnsAddress1 + || modelItem == mIpv6DnsAddress2) { + // IPv6 IP address + editorInterface.setInputConstraints( + HbEditorConstraintLatinAlphabetOnly); + editorInterface.setFilter(CpIpv6Filter::instance()); + edit->setInputMethodHints( + Qt::ImhNoPredictiveText + | Qt::ImhPreferLowercase); + edit->setMaxLength(CMManagerShim::CmIP6NameServerLength); + } else if (modelItem == mProxyServer) { + // Proxy server address + editorInterface.setMode(HbInputModeNone); + editorInterface.setInputConstraints( + HbEditorConstraintLatinAlphabetOnly); + editorInterface.setFilter(HbUrlFilter::instance()); + editorInterface.setEditorClass(HbInputEditorClassUrl); + editorInterface.setDigitType(HbDigitTypeNone); + edit->setInputMethodHints( + Qt::ImhNoPredictiveText + | Qt::ImhPreferLowercase); + edit->setMaxLength(CMManagerShim::CmProxyServerNameLength); + } else { /* mProxyPort */ + // Proxy port number + editorInterface.setMode(HbInputModeNumeric); + edit->setInputMethodHints(Qt::ImhDigitsOnly); + edit->setMaxLength(CMManagerShim::CmProxyPortNumberLength); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_SETEDITORPREFERENCES_EXIT); +} + +/*! + Handles change to IPv4 address mode (automatic/user defined). +*/ +void CpWlanApAdvancedView::changeIpv4AddressMode(int state) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_ENTRY); + + bool ipv4AddressFromServer; + if (state == Qt::Checked) { + ipv4AddressFromServer = true; + } else { + ipv4AddressFromServer = false; + } + + if (!ipv4AddressFromServer + && getIpAddress(CMManagerShim::CmIPAddress) == + CMManagerShim::UnspecifiedIpv4Address) { + // User defined IP address selected, but no valid address is stored. + // Just enable the UI IP editors, because CMManager will update the + // "IP address from server" flag by itself when a valid IP address + // is stored. + enableIpv4AddressFields(state); + } else { + // Save setting to CommsDat + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPAddrFromServer, + ipv4AddressFromServer); + if (tryUpdate()) { + enableIpv4AddressFields(state); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESSMODE_EXIT); +} + +/*! + Saves IPv4 address to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv4Address() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4Address, + CMManagerShim::CmIPAddress, + QAbstractSocket::IPv4Protocol)) { + // In case the IP address is empty or 0.0.0.0, CMManager changes the + // "IP address from server" flag to true. We need to refresh the UI to + // make sure we are in sync. + updateIpv4Group(); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4ADDRESS_EXIT); +} + +/*! + Saves IPv4 subnet mask to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv4SubnetMask() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_ENTRY); + + (void)validateAndSaveIpAddress( + mIpv4SubnetMask, + CMManagerShim::CmIPNetmask, + QAbstractSocket::IPv4Protocol); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SUBNETMASK_EXIT); +} + +/*! + Saves IPv4 gateway to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv4Gateway() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_ENTRY); + + (void)validateAndSaveIpAddress( + mIpv4Gateway, + CMManagerShim::CmIPGateway, + QAbstractSocket::IPv4Protocol); + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4GATEWAY_EXIT); +} + +/*! + Handles change to IPv4 DNS mode (automatic/user defined). +*/ +void CpWlanApAdvancedView::changeIpv4DnsMode(int state) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_ENTRY); + + bool dnsAddressFromServer; + if (state == Qt::Checked) { + dnsAddressFromServer = true; + } else { + dnsAddressFromServer = false; + } + // Save setting to CommsDat + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + dnsAddressFromServer); + if (tryUpdate()) { + enableIpv4DnsFields(state); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4DNSMODE_EXIT); +} + +/*! + Saves IPv4 primary DNS address to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv4PrimaryDnsAddress() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4DnsAddress1, + CMManagerShim::CmIPNameServer1, + QAbstractSocket::IPv4Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0.0.0.0, CMManager will + // check secondary DNS address and in case it is a valid address, + // move it to the primary DNS address. We need to refresh the + // UI to make sure we are in sync. If tryUpdate() fails it does + // the refresh automatically, so only success case is handled + // here. + updateIpv4Group(); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4PRIMARYDNSADDRESS_EXIT); +} + +/*! + Saves IPv4 secondary DNS address to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv4SecondaryDnsAddress() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv4DnsAddress2, + CMManagerShim::CmIPNameServer2, + QAbstractSocket::IPv4Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIPDNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0.0.0.0, CMManager will + // write the address there instead of secondary DNS address, so we + // need to refresh the UI to make sure we are in sync. If + // tryUpdate() fails it does the refresh automatically, so only + // success case is handled here. + updateIpv4Group(); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV4SECONDARYDNSADDRESS_EXIT); +} + +/*! + Handles change to IPv6 DNS mode (automatic/well-known/user defined). +*/ +void CpWlanApAdvancedView::changeIpv6DnsMode(int state) +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_ENTRY); + + // Update "DNS address from server" flag + if (state == Ipv6DnsTypeAutomatic) { + // Automatic + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + true); + } else { + // User defined or well-known address + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + + if (state == Ipv6DnsTypeWellKnown) { + // Well-known address, set DNS addresses and update UI + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmIP6NameServer1, + CMManagerShim::KnownIpv6NameServer1); + mIpv6DnsAddress1->setContentWidgetData( + "text", + CMManagerShim::KnownIpv6NameServer1); + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmIP6NameServer2, + CMManagerShim::KnownIpv6NameServer2); + mIpv6DnsAddress2->setContentWidgetData( + "text", + CMManagerShim::KnownIpv6NameServer2); + } + } + + if (tryUpdate()) { + enableIpv6DnsFields(state); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6DNSMODE_EXIT); +} + +/*! + Saves IPv6 primary DNS address to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv6PrimaryDnsAddress() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv6DnsAddress1, + CMManagerShim::CmIP6NameServer1, + QAbstractSocket::IPv6Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, + // CMManager will check secondary DNS address and in case it is a + // valid address, move it to the primary DNS address. We need to + // refresh the UI to make sure we are in sync. If tryUpdate() + // fails it does the refresh automatically, so only success case + // is handled here. + updateIpv6Group(); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6PRIMARYDNSADDRESS_EXIT); +} + +/*! + Saves IPv6 secondary DNS address to CommsDat. +*/ +void CpWlanApAdvancedView::changeIpv6SecondaryDnsAddress() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_ENTRY); + + if (validateAndSaveIpAddress( + mIpv6DnsAddress2, + CMManagerShim::CmIP6NameServer2, + QAbstractSocket::IPv6Protocol)) { + // Address saved successfully, update "DNS address from server" flag + mCmConnectionMethod->setBoolAttribute( + CMManagerShim::CmIP6DNSAddrFromServer, + false); + if (tryUpdate()) { + // In case primary DNS address is empty or 0:0:0:0:0:0:0:0, + // CMManager will write the address there instead of secondary DNS + // address, so we need to refresh the UI to make sure we are in + // sync. If tryUpdate() fails it does the refresh automatically, + // so only success case is handled here. + updateIpv6Group(); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEIPV6SECONDARYDNSADDRESS_EXIT); +} + +/*! + Saves proxy server address to CommsDat. +*/ +void CpWlanApAdvancedView::changeProxyServer() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_ENTRY); + + QString proxyServer = mProxyServer->contentWidgetData("text").toString(); + mCmConnectionMethod->setStringAttribute( + CMManagerShim::CmProxyServerName, + proxyServer); + if (tryUpdate()) { + // If proxy server name is empty, CMManager will also clear the + // proxy port. Therefore UI needs to be updated. + updateProxyGroup(); + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYSERVER_EXIT); +} + +/*! + Saves proxy port to CommsDat. +*/ +void CpWlanApAdvancedView::changeProxyPort() +{ + OstTraceFunctionEntry0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_ENTRY); + + uint proxyPort = mProxyPort->contentWidgetData("text").toInt(); + if (proxyPort <= 65535) { + if (proxyPort == 0) { + // Don't show zero + mProxyPort->setContentWidgetData("text", ""); + } + mCmConnectionMethod->setIntAttribute( + CMManagerShim::CmProxyPortNumber, + proxyPort); + (void)tryUpdate(); + } else { + // Inform user of invalid value + showMessageBox( + HbMessageBox::MessageTypeInformation, + hbTrId("txt_occ_info_invalid_input")); + // Restore previous setting + proxyPort = mCmConnectionMethod->getIntAttribute( + CMManagerShim::CmProxyPortNumber); + if (proxyPort > 0) { + mProxyPort->setContentWidgetData("text", QVariant(proxyPort)); + } else { + mProxyPort->setContentWidgetData("text", ""); + } + } + + OstTraceFunctionExit0(CPWLANAPADVANCEDVIEW_CHANGEPROXYPORT_EXIT); +}