diff -r 35baca0e7a2e -r 023eef975703 javamanager/javasettings_qt/src/javaapplicationsettingsview_p.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javasettings_qt/src/javaapplicationsettingsview_p.cpp	Fri Jul 09 16:35:45 2010 +0300
@@ -0,0 +1,1158 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include <hbmessagebox.h>
+#include <hbdataformviewitem.h>
+#include <hbcombobox.h>
+#include <hbpushbutton.h>
+#include <hbdataform.h>
+#include <hbdataformmodel.h>
+#include <hbdataformmodelitem.h>
+#include <hblabel.h>
+#include <hbaction.h>
+#include <QApplication>
+#include <QTranslator>
+#include <QLibraryInfo>
+#include <qnetworkconfigmanager.h>
+#include <qnetworkconfiguration.h>
+#include <algorithm>
+
+#include "javaapplicationsettings.h"
+#include "javaapplicationsettingsview.h"
+#include "javaapplicationsettingsview_p.h"
+#include "connectionmanager.h"
+#include "javacommonutils.h"
+
+#include "securitystoragedatadefs.h"
+#include "javastoragenames.h"
+
+#include "logger.h"
+
+QTM_USE_NAMESPACE
+
+using namespace java::settings;
+using namespace java::storage;
+using namespace java::util;
+using namespace std;
+
+const wchar_t ON_SCREEN_KEYPAD_VALUE_NO[] = L"0";
+const wchar_t ON_SCREEN_KEYPAD_VALUE_GAMEACTIONS[] = L"1";
+const wchar_t ON_SCREEN_KEYPAD_VALUE_NAVIGATION[] = L"2";
+
+JavaApplicationSettingsViewPrivate::JavaApplicationSettingsViewPrivate(const QString& aJavaAppUid):
+        mMainForm(0), mModel(0), mGeneralSettingsGroup(0), mSecuritySettingsGroup(0), mNetConnSettingsUi(0), mAsyncToSyncCallEventLoop(0), mSecWarningAccepted(false), mDefaultConnId(0)
+{
+    // init common values
+    init();
+
+    // init the suite UID from the application UID
+    readSuiteUid(aJavaAppUid);
+    if (mSuiteUid.size() <= 0)
+    {
+        ELOG1(EJavaSettings, "No suite found with uid %S", aJavaAppUid.toStdWString().c_str());
+        return;
+    }
+    ELOG1(EJavaSettings, "Initializing settings for suite %S", mSuiteUid.c_str());
+    
+    // init access point settings ui
+    mNetConnSettingsUi = new CmApplSettingsUi(this);
+    mAsyncToSyncCallEventLoop = new QEventLoop();
+
+    // read all settings
+    readAllSettings();
+
+    // init form
+    mMainForm = new HbDataForm();
+    mMainForm->setHeading(QString::fromStdWString(readFromStorage(PACKAGE_NAME, L"", L"", APPLICATION_PACKAGE_TABLE)));
+    mModel = new HbDataFormModel();
+
+    // init settings
+    mGeneralSettingsGroup = mModel->appendDataFormGroup(
+        QString(hbTrId(ID_GENERAL_GROUP_TITLE)), mModel->invisibleRootItem());
+    initSettings(mGeneralSettings, mGeneralSettingsGroup);
+    // append the security settings only if there are any user settings
+    if (mExtraSettings.size() > 0)
+    {
+        mSecuritySettingsGroup = mModel->appendDataFormGroup(
+            QString(hbTrId(ID_SECURITY_GROUP_TITLE)), mModel->invisibleRootItem());
+        initSettings(mSecuritySettings, mSecuritySettingsGroup);
+
+        // if security warnings is user defined -> add the extra settings, expand
+        if (mSecuritySettings[0].getCurrentValue() == 1)
+        {
+            securityWarningsChanged(TXT_USER_DEFINED);
+        }
+    }
+
+    // link form and model
+    mMainForm->setModel(mModel);
+    mMainForm->setExpanded(mModel->indexFromItem(mGeneralSettingsGroup), true);
+    if (mExtraSettings.size() > 0)
+    {
+        mMainForm->setExpanded(mModel->indexFromItem(mSecuritySettingsGroup), (mSecuritySettings[0].getCurrentValue() == 1));
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::init(JavaApplicationSettingsView* aPublicView)
+{
+    mPublicView = aPublicView;
+
+    if (mMainForm)
+    {
+        // do the connect for the main form
+        mPublicView->connect(mMainForm, SIGNAL(itemShown(const QModelIndex)),
+                             mPublicView, SLOT(_q_dataItemDisplayed(const QModelIndex)));
+
+        // set the form as view's widget
+        mPublicView->setWidget(mMainForm);
+    }
+    else
+    {
+        // no settings available
+        HbLabel* label = new HbLabel(TXT_SETTINGS_NOT_AVAILABLE, mPublicView);
+        label->setAlignment(Qt::AlignVCenter);
+    }
+
+    // set title
+    mPublicView->setTitle(TXT_SETTINGS_TITLE);
+}
+
+JavaApplicationSettingsViewPrivate::~JavaApplicationSettingsViewPrivate()
+{
+    delete mMainForm;
+    delete mModel;
+    delete mNetConnSettingsUi;
+    delete mAsyncToSyncCallEventLoop;
+    foreach (QTranslator *translator, mTranslators) {
+        qApp->removeTranslator(translator);
+    }
+    qDeleteAll(mTranslators);
+    mTranslators.clear();
+}
+
+void JavaApplicationSettingsViewPrivate::readAllSettings()
+{
+    // general settings
+    initGeneralSettings();
+
+    // security settings
+    initSecuritySettings();
+}
+
+void JavaApplicationSettingsViewPrivate::init()
+{
+    // init storage
+    try
+    {
+        mStorage.reset(JavaStorage::createInstance());
+        mStorage->open();
+    }
+    catch (JavaStorageException& aJse)
+    {
+        ELOG1(EJavaSettings, "Error while opening the storage %S", aJse.toString().c_str());
+    }
+
+    QTranslator translator;
+    // load the correct translation of the localized strings for the cmmanager.
+    // Load this one first since it contains the smallest amount of strings
+    // (so it's ok to be searched last)
+    installTranslator("cmapplsettingsui");
+    installTranslator("cmmanager");
+    // load the correct translation of the localized strings for the java settings
+    // Current solution reads it from Z only (this does not work with IAD)
+    // -> check if translator can handle path without drive letter (e.g. the resource
+    // is loaded from the same drive where the DLL is loaded)
+    installTranslator("javaruntimeapplicationsettings");
+    // init strings
+    TXT_BLANKET = QString(hbTrId(ID_BLANKET));
+    TXT_SESSION = QString(hbTrId(ID_SESSION));
+    TXT_ONESHOT = QString(hbTrId(ID_ONESHOT));
+    TXT_DENIED = QString(hbTrId(ID_DENIED));
+    TXT_SECURITY_LEVEL = QString(hbTrId(ID_SECURITY_LEVEL));
+    TXT_USER_DEFINED = QString(hbTrId(ID_USER_DEFINED));
+    TXT_SENSITIVE_SETTINGS = QString(hbTrId(ID_SENSITIVE_SETTINGS));
+    TXT_SENSITIVE_SETTINGS_NET_USAGE = QString(hbTrId(ID_SENSITIVE_SETTINGS_NET_USAGE));
+    TXT_MUTUALLY_EXCLUSIVE_SETTINGS = QString(hbTrId(ID_MUTUALLY_EXCLUSIVE_SETTINGS));
+    TXT_OK = QString(hbTrId(ID_OK));
+    TXT_CANCEL = QString(hbTrId(ID_CANCEL));
+    TXT_SECURITY_WARNING_TITLE = QString(hbTrId(ID_SECURITY_WARNING_TITLE));
+    TXT_NET_ACCESS = QString(hbTrId(ID_NET_ACCESS));
+    TXT_LOW_LEVEL_NET_ACCESS = QString(hbTrId(ID_LOW_LEVEL_NET_ACCESS));
+    TXT_NETWORK_CONNECTION = QString(hbTrId(ID_NETWORK_CONNECTION));
+    TXT_SETTINGS_TITLE = QString(hbTrId(ID_SETTINGS_TITLE));
+    TXT_SETTINGS_NOT_AVAILABLE = QString(hbTrId(ID_SETTINGS_NOT_AVAILABLE));
+
+    // init the known localized settings names
+    mLocalizedSettingsNames[QString::fromStdWString(NET_ACCESS_SETTINGS)] = TXT_NET_ACCESS;
+    mLocalizedSettingsNames[QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS)] = TXT_LOW_LEVEL_NET_ACCESS;
+    mLocalizedSettingsNames[QString::fromStdWString(MESSAGING_SETTINGS)] = QString(hbTrId(ID_MESSAGING));
+    mLocalizedSettingsNames[QString::fromStdWString(RESTRICTED_MESSAGING_SETTINGS)] = QString(hbTrId(ID_RESTRICTED_MESSAGING));
+    mLocalizedSettingsNames[QString::fromStdWString(CALL_CONTROL_SETTINGS)] = QString(hbTrId(ID_CALL_CONTROL));
+    mLocalizedSettingsNames[QString::fromStdWString(LOCAL_CONNECTIVITY_SETTINGS)] = QString(hbTrId(ID_LOCAL_CONNECTIVITY));
+    mLocalizedSettingsNames[QString::fromStdWString(MULTIMEDIA_RECORDING_SETTINGS)] = QString(hbTrId(ID_MULTIMEDIA_RECORDING));
+    mLocalizedSettingsNames[QString::fromStdWString(WRITE_USER_DATA_ACCESS_SETTINGS)] = QString(hbTrId(ID_WRITE_USER_DATA_ACCESS));
+    mLocalizedSettingsNames[QString::fromStdWString(READ_USER_DATA_ACCESS_SETTINGS)] = QString(hbTrId(ID_READ_USER_DATA_ACCESS));
+    mLocalizedSettingsNames[QString::fromStdWString(LOCATION_SETTINGS)] = QString(hbTrId(ID_LOCATION));
+    mLocalizedSettingsNames[QString::fromStdWString(LANDMARK_SETTINGS)] = QString(hbTrId(ID_LANDMARK));
+    mLocalizedSettingsNames[QString::fromStdWString(AUTHENTICATION_SETTINGS)] = QString(hbTrId(ID_AUTHENTICATION));
+    mLocalizedSettingsNames[QString::fromStdWString(SMART_CARD_COMMUNICATION_SETTINGS)] = QString(hbTrId(ID_SMART_CARD_COMMUNICATION));
+    mLocalizedSettingsNames[QString::fromStdWString(APPLICATION_AUTO_INVOCATION_SETTINGS)] = QString(hbTrId(ID_APPLICATION_AUTO_INVOCATION));
+    mLocalizedSettingsNames[QString::fromStdWString(BROADCAST_SETTINGS)] = QString(hbTrId(ID_BROADCAST));
+    mLocalizedSettingsNames[QString::fromStdWString(NFC_WRITE_ACCESS_SETTINGS)] = QString(hbTrId(ID_NFC_WRITE_ACCESS));
+    mLocalizedSettingsNames[QString::fromStdWString(URL_START_SETTINGS)] = QString(hbTrId(ID_URL_START));
+    // init the display indexes associated with each settings
+    mSettingsNamesIndexes[QString::fromStdWString(NET_ACCESS_SETTINGS)] = NET_ACCESS_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS)] = LOW_LEVEL_NET_ACCESS_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(MESSAGING_SETTINGS)] = MESSAGING_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(RESTRICTED_MESSAGING_SETTINGS)] = RESTRICTED_MESSAGING_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(CALL_CONTROL_SETTINGS)] = CALL_CONTROL_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(LOCAL_CONNECTIVITY_SETTINGS)] = LOCAL_CONNECTIVITY_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(MULTIMEDIA_RECORDING_SETTINGS)] = MULTIMEDIA_RECORDING_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(WRITE_USER_DATA_ACCESS_SETTINGS)] = WRITE_USER_DATA_ACCESS_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(READ_USER_DATA_ACCESS_SETTINGS)] = READ_USER_DATA_ACCESS_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(LOCATION_SETTINGS)] = LOCATION_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(LANDMARK_SETTINGS)] = LANDMARK_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(AUTHENTICATION_SETTINGS)] = AUTHENTICATION_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(SMART_CARD_COMMUNICATION_SETTINGS)] = SMART_CARD_COMMUNICATION_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(APPLICATION_AUTO_INVOCATION_SETTINGS)] = APPLICATION_AUTO_INVOCATION_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(BROADCAST_SETTINGS)] = BROADCAST_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(NFC_WRITE_ACCESS_SETTINGS)] = NFC_WRITE_ACCESS_SETTINGS_INDEX;
+    mSettingsNamesIndexes[QString::fromStdWString(URL_START_SETTINGS)] = URL_START_SETTINGS_INDEX;
+}
+
+
+void JavaApplicationSettingsViewPrivate::initGeneralSettings()
+{
+    QStringList settingsValues;
+    vector<wstring> storageValues;
+    if (!isInStorage(VALUE, NAME, L"Nokia-MIDlet-On-Screen-Keypad", APPLICATION_PACKAGE_ATTRIBUTES_TABLE))
+    {
+        // if the on screen keypad is predefined, it should not be changable by user
+        // -> right now it is not added to settings list. It should be changed so that
+        // the setting should not be editable by user
+        settingsValues<<QString(hbTrId(ID_OSK_NO))<<QString(hbTrId(ID_OSK_GAME))<<QString(hbTrId(ID_OSK_NAVIGATION));
+        storageValues.push_back(ON_SCREEN_KEYPAD_VALUE_NO);
+        storageValues.push_back(ON_SCREEN_KEYPAD_VALUE_GAMEACTIONS);
+        storageValues.push_back(ON_SCREEN_KEYPAD_VALUE_NAVIGATION);
+        mGeneralSettings.append(JavaApplicationSettings(QString(hbTrId(ID_OSK)), settingsValues, ON_SCREEN_KEYPAD, MIDP_PACKAGE_TABLE, storageValues));
+        readFromStorage(mGeneralSettings[0]);
+    }
+    settingsValues = QStringList();
+    initNetworkConnection();
+    settingsValues<<mNetConn.name;
+    mGeneralSettings.append(JavaApplicationSettings(TXT_NETWORK_CONNECTION, settingsValues));
+    mNetSettIndex = mGeneralSettings.size() - 1;
+}
+
+void JavaApplicationSettingsViewPrivate::initSecuritySettings()
+{
+    QStringList settingsValues;
+    vector<wstring> storageValues;
+    settingsValues = QStringList();
+    storageValues.clear();
+    settingsValues<<QString(hbTrId(ID_SECURITY_LEVEL_DEFAULT))<<TXT_USER_DEFINED;
+    storageValues.push_back(SECURITY_WARNINGS_DEFAULT_MODE);
+    storageValues.push_back(SECURITY_WARNINGS_USER_DEFINED_MODE);
+    mSecuritySettings.append(JavaApplicationSettings(TXT_SECURITY_LEVEL, settingsValues, SECURITY_WARNINGS, MIDP_PACKAGE_TABLE, storageValues));
+    readFromStorage(mSecuritySettings[0]);
+
+    // extra settings
+    settingsValues = QStringList();
+    storageValues.clear();
+    settingsValues<<TXT_ONESHOT<<TXT_SESSION<<TXT_BLANKET<<TXT_DENIED;
+    storageValues.push_back(ONESHOT_INTERACTION_MODE);
+    storageValues.push_back(SESSION_INTERACTION_MODE);
+    storageValues.push_back(BLANKET_INTERACTION_MODE);
+    storageValues.push_back(DENIED_INTERACTION_MODE);
+    vector<IndexedSettingsName> allSecuritySettings = readFromStorage(FUNCTION_GROUP, MIDP_FUNC_GRP_SETTINGS_TABLE, MIDP_PERMISSIONS_TABLE);
+    // sort the security settings according to how they should be displayed
+    std::sort(allSecuritySettings.begin(), allSecuritySettings.end(), AscendingSort());
+    for(int i=0; i<allSecuritySettings.size(); i++)
+    {
+        QString rawSettingsName = QString::fromStdWString(allSecuritySettings[i].name);
+        QString localizedSettingsName = rawSettingsName;
+        if (mLocalizedSettingsNames.contains(rawSettingsName))
+            localizedSettingsName = mLocalizedSettingsNames.value(rawSettingsName);
+        mExtraSettings.append(JavaApplicationSettings(
+            localizedSettingsName, settingsValues, CURRENT_SETTING,
+            MIDP_FUNC_GRP_SETTINGS_TABLE, storageValues, FUNCTION_GROUP,
+            allSecuritySettings[i].name, ALLOWED_SETTINGS));
+        readFromStorage(mExtraSettings[i]);
+        mSettingsIndexes[rawSettingsName] = i;
+    }
+
+    // configure the high risk lists
+    configureLists();
+}
+
+void JavaApplicationSettingsViewPrivate::configureLists()
+{
+    QList<JavaApplicationSettings*> highRiskList;
+    QStringList highRiskSettingsNames;
+    highRiskSettingsNames
+        <<QString::fromStdWString(MULTIMEDIA_RECORDING_SETTINGS)
+        <<QString::fromStdWString(READ_USER_DATA_ACCESS_SETTINGS);
+    configureList(highRiskList, highRiskSettingsNames, mSettingsIndexes);
+    // net access with multimedia and read user data
+    attachList(QString::fromStdWString(NET_ACCESS_SETTINGS),highRiskList, mSettingsIndexes);
+    // low level net access with multimedia and read user data
+    attachList(QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS),highRiskList, mSettingsIndexes);
+    // messaging with multimedia and read user data
+    attachList(QString::fromStdWString(MESSAGING_SETTINGS),highRiskList, mSettingsIndexes);
+    // restricted messaging with multimedia and read user data
+    attachList(QString::fromStdWString(RESTRICTED_MESSAGING_SETTINGS),highRiskList, mSettingsIndexes);
+    // call control with multimedia and read user data
+    attachList(QString::fromStdWString(CALL_CONTROL_SETTINGS),highRiskList, mSettingsIndexes);
+    // local connectivity with multimedia and read user data
+    attachList(QString::fromStdWString(LOCAL_CONNECTIVITY_SETTINGS),highRiskList, mSettingsIndexes);
+    // multimedia with net access, low level net access, messaging,
+    // restricted messaging, call control and local connectivity
+    highRiskList.clear();
+    highRiskSettingsNames.clear();
+    highRiskSettingsNames
+        <<QString::fromStdWString(NET_ACCESS_SETTINGS)
+        <<QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS)
+        <<QString::fromStdWString(MESSAGING_SETTINGS)
+        <<QString::fromStdWString(RESTRICTED_MESSAGING_SETTINGS)
+        <<QString::fromStdWString(CALL_CONTROL_SETTINGS)
+        <<QString::fromStdWString(LOCAL_CONNECTIVITY_SETTINGS)
+        <<QString::fromStdWString(MULTIMEDIA_RECORDING_SETTINGS);
+    configureList(highRiskList, highRiskSettingsNames, mSettingsIndexes);
+    attachList(QString::fromStdWString(MULTIMEDIA_RECORDING_SETTINGS),highRiskList, mSettingsIndexes);
+    // read user data with net access, low level net access, messaging,
+    // restricted messaging, call control and local connectivity
+    attachList(QString::fromStdWString(READ_USER_DATA_ACCESS_SETTINGS),highRiskList, mSettingsIndexes);
+
+    // configure the mutually exclusive list
+    QList<JavaApplicationSettings*> mutuallyExclusiveList;
+    QStringList mutuallyExclusiveSettingsNames;
+    mutuallyExclusiveSettingsNames
+        <<QString::fromStdWString(APPLICATION_AUTO_INVOCATION_SETTINGS);
+    configureList(mutuallyExclusiveList, mutuallyExclusiveSettingsNames, mSettingsIndexes);
+    //net access with application auto invocation
+    attachList(QString::fromStdWString(NET_ACCESS_SETTINGS),mutuallyExclusiveList, mSettingsIndexes, false /* is high risk list */);
+    //low level net access with application auto invocation
+    attachList(QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS),mutuallyExclusiveList, mSettingsIndexes, false /* is high risk list */);
+    //application auto invocation with net access and low level net access
+    mutuallyExclusiveList.clear();
+    mutuallyExclusiveSettingsNames.clear();
+    mutuallyExclusiveSettingsNames
+        <<QString::fromStdWString(NET_ACCESS_SETTINGS)
+        <<QString::fromStdWString(LOW_LEVEL_NET_ACCESS_SETTINGS);
+    configureList(mutuallyExclusiveList, mutuallyExclusiveSettingsNames, mSettingsIndexes);
+    attachList(QString::fromStdWString(APPLICATION_AUTO_INVOCATION_SETTINGS),mutuallyExclusiveList, mSettingsIndexes, false /* is high risk list */);
+}
+
+void JavaApplicationSettingsViewPrivate::initSettings(QVector<JavaApplicationSettings>& aSettings, HbDataFormModelItem * aParent)
+{
+    for (int i=0; i<aSettings.size(); i++)
+    {
+        HbDataFormModelItem * appSettings = NULL;
+        int currentValue = 0;
+        switch(aSettings[i].getValues().size())
+        {
+            case 1:
+                appSettings  = mModel->appendDataFormItem(
+                        HbDataFormModelItem::ToggleValueItem,
+                        aSettings[i].getName(), aParent);
+                // make it a toogle button (-> get rid of the "pressed" ui effect)
+                if (appSettings)
+                {
+                    appSettings->setContentWidgetData(QString("text"), aSettings[i].getValues()[0]);
+                    appSettings->setContentWidgetData(QString("additionalText"), aSettings[i].getValues()[0]);
+                }
+                break;
+            case 2:
+                appSettings  = mModel->appendDataFormItem(
+                        HbDataFormModelItem::ToggleValueItem,
+                        aSettings[i].getName(), aParent);
+                if (appSettings)
+                {
+                    currentValue = aSettings[i].getCurrentValue();
+                    if (currentValue < 0)
+                    {
+                        currentValue = 0;
+                    }
+                    appSettings->setContentWidgetData(QString("text"), aSettings[i].getValues()[currentValue]);
+                    appSettings->setContentWidgetData(QString("additionalText"),aSettings[i].getValues()[1 - currentValue]);
+                }
+                break;
+            default:
+                appSettings  = mModel->appendDataFormItem(
+                        HbDataFormModelItem::ComboBoxItem,
+                        aSettings[i].getName(), aParent);
+                if (appSettings)
+                {
+                    appSettings->setContentWidgetData(QString("items"), aSettings[i].getValues());
+                    appSettings->setContentWidgetData(QString("currentIndex"),aSettings[i].getCurrentValue());
+                }
+        }
+        aSettings[i].setId(appSettings);
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::writeSettings(JavaApplicationSettings& aSettings, const QString &aNewValue)
+{
+    QStringList values = aSettings.getValues();
+    int currentValue = aSettings.getCurrentValue();
+    int newValue = aSettings.getValueIndex(aNewValue);
+    if (newValue != -1 && currentValue != newValue)
+    {
+        // handle blanket settings
+        if (aNewValue == TXT_BLANKET)
+        {
+            // check blanket settings
+            if (!isBlanketAllowed(aSettings))
+            {
+                // change back to the old value
+                HbComboBox * settingsCombo = static_cast<HbComboBox*>(itemToWidget(aSettings.getId()));
+                if (settingsCombo)
+                {
+                    settingsCombo->setCurrentIndex(currentValue);
+                }
+                return;
+            }
+        }
+        aSettings.setCurrentValue(newValue);
+        writeToStorage(aSettings);
+    }
+}
+
+bool JavaApplicationSettingsViewPrivate::isBlanketAllowed(const JavaApplicationSettings& aSettings)
+{
+    // handle the high risk items
+    QList<JavaApplicationSettings*> highRiskList = aSettings.getHighRiskList();
+    // go through the list and see if any of the setings are in blanket
+    for (int i=0; i<highRiskList.size(); i++)
+    {
+        if (highRiskList[i] &&
+                highRiskList[i]->getValue(highRiskList[i]->getCurrentValue())
+                == TXT_BLANKET)
+        {
+            QString secWarning = TXT_SENSITIVE_SETTINGS;
+            QString LOCAL_CONNECTIVITY = QString(hbTrId(ID_LOCAL_CONNECTIVITY));
+            if (aSettings.getName() != LOCAL_CONNECTIVITY
+                && highRiskList[i]->getName() != LOCAL_CONNECTIVITY)
+            {
+                secWarning = TXT_SENSITIVE_SETTINGS_NET_USAGE;
+            }
+            if (!isSecurityWarningAccepted(
+                secWarning,TXT_OK,TXT_CANCEL ,TXT_SECURITY_WARNING_TITLE))
+            {
+                LOG3(EJavaSettings, EInfo,"User did not accept the high risk due to having both \"%S\" and \"%S\" set to \"%S\"", aSettings.getName().toStdWString().c_str(), highRiskList[i]->getName().toStdWString().c_str(), TXT_BLANKET.toStdWString().c_str());
+                return false;
+            }
+            LOG3(EJavaSettings, EInfo,"User accepted the high risk due to having both \"%S\" and \"%S\" set to \"%S\"", aSettings.getName().toStdWString().c_str(), highRiskList[i]->getName().toStdWString().c_str(), TXT_BLANKET.toStdWString().c_str());
+            break;
+        }
+    }
+    // handle the mutually exclusive rules
+    QList<JavaApplicationSettings*> mutuallyExclusiveList = aSettings
+            .getMutuallyExclusiveList();
+    // go through the list and see if any of the setings are in blanket
+    for (int i=0; i<mutuallyExclusiveList.size(); i++)
+    {
+        if (mutuallyExclusiveList[i] && mutuallyExclusiveList[i]->getValue(
+                    mutuallyExclusiveList[i]->getCurrentValue()) == TXT_BLANKET)
+        {
+            bool isBlanketAllowed = isSecurityWarningAccepted(
+                TXT_MUTUALLY_EXCLUSIVE_SETTINGS, TXT_OK, TXT_CANCEL, TXT_SECURITY_WARNING_TITLE);
+            if (isBlanketAllowed)
+            {
+                // change  the current value to the maximum allowed
+                bool isBlanket = true;
+                do
+                {
+                    if (isBlanket)
+                    {
+                        QStringList allowedValues = mutuallyExclusiveList[i]->getValues();
+                        int selectedValue = mutuallyExclusiveList[i]->getCurrentValue();
+                        // select the maximum allowed value
+                        for (int j=0; j<allowedValues.size(); j++)
+                        {
+                            if (allowedValues[j] == TXT_SESSION)
+                            {
+                                selectedValue = j;
+                                break;
+                            }
+                            if (allowedValues[j] == TXT_ONESHOT)
+                            {
+                                selectedValue = j;
+                            }
+                            else if (allowedValues[j] == TXT_DENIED
+                                     && allowedValues[selectedValue] == TXT_BLANKET)
+                            {
+                                selectedValue = j;
+                            }
+                        }
+                        // set the maximum allowed value
+                        mutuallyExclusiveList[i]->setCurrentValue(selectedValue);
+                        HbComboBox * settingsCombo = static_cast<HbComboBox*>(itemToWidget(
+                                                         mutuallyExclusiveList[i]->getId()));
+                        if (settingsCombo)
+                        {
+                            settingsCombo->setCurrentIndex(selectedValue);
+                        }
+                        writeToStorage(*mutuallyExclusiveList[i]);
+                        LOG4(EJavaSettings, EInfo,"Changing \"%S\" to \"%S\" led to changing \"%S\" to \"%S\" due to mutually exclusive rules", aSettings.getName().toStdWString().c_str(), TXT_BLANKET.toStdWString().c_str(), mutuallyExclusiveList[i]->getName().toStdWString().c_str(), allowedValues[selectedValue].toStdWString().c_str());
+                    }
+                    i++;
+                    // end of list?
+                    if (i >= mutuallyExclusiveList.size())
+                    {
+                        break;
+                    }
+                    // move on into the list
+                    isBlanket = (mutuallyExclusiveList[i]->getValue(
+                                     mutuallyExclusiveList[i]->getCurrentValue()) == TXT_BLANKET);
+                }
+                while (true);
+            }
+            else
+            {
+                LOG1(EJavaSettings, EInfo,"User did not accept changes in \"%S\" due to mutually exclusive rules", mutuallyExclusiveList[i]->getName().toStdWString().c_str());
+            }
+            return isBlanketAllowed;
+        }
+    }
+    return true;
+}
+
+void JavaApplicationSettingsViewPrivate::_q_settingsChanged(bool)
+{
+    HbPushButton * sender = static_cast<HbPushButton*>(mPublicView->sender());
+    if (sender)
+    {
+        JavaApplicationSettings* settings = findSettings(sender);
+        if (settings == NULL)
+        {
+            return;
+        }
+        if (settings->getName() == TXT_SECURITY_LEVEL)
+        {
+            QString newValue = settings->getValue(1 - settings->getCurrentValue());
+            securityWarningsChanged(newValue);
+            writeSettings(*settings, newValue);
+        }
+        else if (settings->getName() == TXT_NETWORK_CONNECTION)
+        {
+            handleNetworkSettings();
+        }
+    }
+}
+void JavaApplicationSettingsViewPrivate::_q_settingsChanged(const QString& aNewValue)
+{
+    HbComboBox * sender = static_cast<HbComboBox*>(mPublicView->sender());
+    if (sender)
+    {
+        JavaApplicationSettings* settings = findSettings(sender);
+        if (settings != NULL)
+        {
+            // any other settings are treated same
+            writeSettings(*settings, aNewValue);
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::securityWarningsChanged(const QString& aNewValue)
+{
+    if (aNewValue == TXT_USER_DEFINED)
+    {
+        // append the extra settings and values
+        for (int i=0; i<mExtraSettings.size(); i++)
+        {
+            if (mExtraSettings[i].getCurrentValue() >= 0 && mExtraSettings[i].getId() == 0)
+            {
+                HbDataFormModelItem * appSettings = mModel->appendDataFormItem(
+                                                        HbDataFormModelItem::ComboBoxItem,
+                                                        mExtraSettings[i].getName(), mSecuritySettingsGroup);
+                if (appSettings)
+                {
+                    mExtraSettings[i].setId(appSettings);
+                    // when settings the items, the settingsChanged signal gets emitted with the first value
+                    // as being the current value. This signal should be discarded (the first value is just
+                    // an intermediate value towards the actual current value which gets set shortly).
+                    // Therefore set the first value as the current value (this way the settingsChanged
+                    // signal gets discarded) and change the current value back to the real current value
+                    int currentValue = mExtraSettings[i].getCurrentValue();
+                    mExtraSettings[i].setCurrentValue(0);
+                    appSettings->setContentWidgetData(QString("items"), mExtraSettings[i].getValues());
+                    mExtraSettings[i].setCurrentValue(currentValue);
+                    appSettings->setContentWidgetData(QString("currentIndex"),mExtraSettings[i].getCurrentValue());
+                }
+            }
+        }
+    }
+    else
+    {
+        // remove the extra settings
+        for (int i=0; i<mExtraSettings.size(); i++)
+        {
+            if (mExtraSettings[i].getId())
+            {
+                HbComboBox * extraSettingsId = static_cast<HbComboBox*>(itemToWidget(mExtraSettings[i].getId()));
+                if (extraSettingsId)
+                {
+                    mPublicView->disconnect(extraSettingsId, 0, 0, 0);
+                    mModel->removeItem(mModel->indexFromItem(mExtraSettings[i].getId()));
+                    mExtraSettings[i].setId(0);
+                    mExtraSettings[i].disconnectFromUi();
+                }
+            }
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::handleNetworkSettings()
+{
+    // init flags to show destinations and connection methods
+    QFlags<CmApplSettingsUi::SelectionDialogItems> listItems;
+    listItems |= CmApplSettingsUi::ShowDestinations;
+    listItems |= CmApplSettingsUi::ShowConnectionMethods;
+
+    // empty filter -> all bearer types included
+    QSet<CmApplSettingsUi::BearerTypeFilter> filter;
+    // reset the result
+    mNetConnSelection.result = mNetConn.type;
+    mNetConnSelection.id = mNetConn.id;
+    // init settings ui with destinations, filter and initial selection
+    mNetConnSettingsUi->setOptions(listItems, filter);
+    mNetConnSettingsUi->setSelection(mNetConnSelection);
+    // Connect the setting ui's signal with own slot where the mNetConnSelection is stored
+    connect(mNetConnSettingsUi, SIGNAL(finished(uint)), this, SLOT(netConnSelected(uint)));
+    // launch the setting ui
+    mNetConnSettingsUi->open();
+}
+
+void JavaApplicationSettingsViewPrivate::_q_dataItemDisplayed(const QModelIndex aDataItemIndex)
+{
+    HbDataFormModelItem *item = static_cast<HbDataFormModel*>(
+                                    mMainForm->model())->itemFromIndex(aDataItemIndex);
+    if (item == NULL)
+    {
+        return;
+    }
+    int itemType = item->data(HbDataFormModelItem::ItemTypeRole).toInt();
+    HbComboBox * comboBox = NULL;
+    HbPushButton * pushButton = NULL;
+    HbWidget * widget = (qobject_cast<HbDataFormViewItem *>
+        (mMainForm->itemByIndex(aDataItemIndex)))->dataItemContentWidget();
+    JavaApplicationSettings* settings = findSettings(widget);
+    if (settings == NULL)
+    {
+        // stop right here
+        return;
+    }
+    switch(HbDataFormModelItem::DataItemType(itemType))
+    {
+        case HbDataFormModelItem::ComboBoxItem:
+            comboBox = static_cast<HbComboBox*>(widget);
+            if (settings->isConnectedToUi())
+            {
+                // need to do a reconnect: disconnect followed by a connect
+                mPublicView->disconnect(comboBox,
+                        SIGNAL(currentIndexChanged(const QString &)),
+                        mPublicView,
+                        SLOT(_q_settingsChanged(const QString &)));
+            }
+            mPublicView->connect(comboBox,
+                                 SIGNAL(currentIndexChanged(const QString &)),
+                                 mPublicView, SLOT(_q_settingsChanged(const QString &)),
+                                 Qt::UniqueConnection);
+            break;
+        case HbDataFormModelItem::ToggleValueItem:
+            pushButton = static_cast< HbPushButton*>(widget);
+            if (settings->isConnectedToUi())
+            {
+                // need to do a reconnect: disconnect followed by a connect
+                mPublicView->disconnect(pushButton,
+                        SIGNAL(clicked(bool)),
+                        mPublicView,
+                        SLOT(_q_settingsChanged(bool)));
+            }
+            mPublicView->connect(pushButton,
+                                 SIGNAL(clicked(bool)),
+                                 mPublicView, SLOT(_q_settingsChanged(bool)),
+                                 Qt::UniqueConnection);
+            break;
+    }
+    settings->connectToUi();
+}
+
+void JavaApplicationSettingsViewPrivate::netConnSelected(uint aNetConnSelectionStatus)
+{
+    if (aNetConnSelectionStatus == CmApplSettingsUi::ApplSettingsErrorNone)
+    {
+        mNetConnSelection = mNetConnSettingsUi->selection();
+        // store the selection
+        if (mNetConnSelection.id != mNetConn.id
+            && mNetConnSelection.id != mDefaultConnId)
+        {
+            TRAPD(err,
+                switch(mNetConnSelection.result)
+                {
+                    case CmApplSettingsUi::SelectionTypeDestination:
+                        ConnectionManager::setDestinationNetworkIdL(mSuiteUid, mNetConnSelection.id);
+                        break;
+                    case CmApplSettingsUi::SelectionTypeConnectionMethod:
+                        ConnectionManager::setApnIdL(mSuiteUid, mNetConnSelection.id);
+                        break;
+                }
+            );
+            if (err == KErrNone)
+            {
+                mNetConn.id = mNetConnSelection.id;
+                mNetConn.type = mNetConnSelection.result;
+                readNetworkConnectionName();
+                mGeneralSettings[mNetSettIndex].getId()->setContentWidgetData(QString("text"), mNetConn.name);
+                mGeneralSettings[mNetSettIndex].getId()->setContentWidgetData(QString("additionalText"), mNetConn.name);
+            }
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::securityWarningDismissed(HbAction* aDismissAction)
+{
+    HbMessageBox *dlg = static_cast<HbMessageBox*>(sender());
+    mSecWarningAccepted = (aDismissAction == dlg->actions().at(0));
+    mAsyncToSyncCallEventLoop->exit();
+}
+
+void JavaApplicationSettingsViewPrivate::initNetworkConnection()
+{
+    TRAP_IGNORE(
+        mNetConn.id = ConnectionManager::getDestinationNetworkIdL(mSuiteUid);
+        if (mNetConn.id == (uint)KJavaNetworkAccessNotSpecified)
+        {
+            mNetConn.id = ConnectionManager::getApnIdL(mSuiteUid);
+        }
+    );
+    QNetworkConfigurationManager manager;
+    QNetworkConfiguration defaultCfg = manager.defaultConfiguration();
+    mDefaultConnId = defaultCfg.identifier().toInt();
+    QNetworkConfiguration cfg = manager.configurationFromIdentifier(
+        QString::number(mNetConn.id));
+    if (!cfg.isValid())
+    {
+        cfg = defaultCfg;
+    }
+    mNetConn.name = QString(hbTrId(cfg.name().toUtf8()));
+}
+
+void JavaApplicationSettingsViewPrivate::readNetworkConnectionName()
+{
+    QNetworkConfigurationManager manager;
+    QNetworkConfiguration cfg = manager.configurationFromIdentifier(
+        QString::number(mNetConn.id));
+    if (!cfg.isValid())
+    {
+        cfg = manager.defaultConfiguration();
+    }
+    mNetConn.name = QString(hbTrId(cfg.name().toUtf8()));
+}
+
+JavaApplicationSettings* JavaApplicationSettingsViewPrivate::findSettings(HbWidget* aId)
+{
+    JavaApplicationSettings* settings = findSettings(aId, mGeneralSettings);
+    if (settings == NULL)
+    {
+        settings = findSettings(aId, mSecuritySettings);
+        if (settings == NULL)
+        {
+            settings = findSettings(aId, mExtraSettings);
+        }
+    }
+    return settings;
+}
+
+JavaApplicationSettings* JavaApplicationSettingsViewPrivate::findSettings(HbWidget* aId, QVector<JavaApplicationSettings>& aAllSettings)
+{
+    for (int i=0; i<aAllSettings.size(); i++)
+    {
+        if (itemToWidget(aAllSettings[i].getId()) == aId)
+        {
+            return &aAllSettings[i];
+        }
+    }
+    return NULL;
+}
+
+HbWidget * JavaApplicationSettingsViewPrivate::itemToWidget(const HbDataFormModelItem * aItem)
+{
+    HbDataFormViewItem * viewItem = qobject_cast<HbDataFormViewItem *> (mMainForm->itemByIndex(
+                                        mModel->indexFromItem(aItem)));
+    if (viewItem)
+    {
+        return static_cast<HbWidget*>(viewItem->dataItemContentWidget());
+    }
+    return NULL;
+}
+
+bool JavaApplicationSettingsViewPrivate::isSecurityWarningAccepted(const QString& aText, const QString& aAcceptActionLabel, const QString& aRejectActionLabel, const QString& aHeadingText)
+{
+    HbMessageBox securityWarning(HbMessageBox::MessageTypeQuestion);
+    securityWarning.setDismissPolicy(HbDialog::NoDismiss);
+    securityWarning.setTimeout(HbDialog::NoTimeout);
+    securityWarning.setIconVisible(false);
+    securityWarning.setText(aText);
+    securityWarning.addAction(new HbAction(
+            aAcceptActionLabel, &securityWarning));
+    securityWarning.addAction(new HbAction(
+            aRejectActionLabel, &securityWarning));
+    securityWarning.setHeadingWidget(new HbLabel(aHeadingText));
+    securityWarning.open(this, SLOT(securityWarningDismissed(HbAction*)));
+    mAsyncToSyncCallEventLoop->exec();
+    return mSecWarningAccepted;
+}
+
+void JavaApplicationSettingsViewPrivate::configureList(QList<JavaApplicationSettings*>& aList, const QStringList& aSettingsNames,  const QHash<QString, int>& aSettingsIndexes)
+{
+    for(int i=0; i<aSettingsNames.size(); i++)
+    {
+        if (aSettingsIndexes.contains(aSettingsNames[i]))
+        {
+            aList << &(mExtraSettings[aSettingsIndexes.value(aSettingsNames[i])]);
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::attachList(const QString& aSettingsName, const QList<JavaApplicationSettings*>& aList, const QHash<QString, int>& aSettingsIndexes, bool aIsHighRiskList)
+{
+    if (aSettingsIndexes.contains(aSettingsName))
+    {
+        if (aIsHighRiskList)
+        {
+            mExtraSettings[aSettingsIndexes.value(aSettingsName)].setHighRiskList(aList);
+        }
+        else
+        {
+            mExtraSettings[aSettingsIndexes.value(aSettingsName)].setMutuallyExclusiveList(aList);
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::installTranslator(const QString& aTranslationFileName)
+{
+    QTranslator* translator = new QTranslator;
+
+    // load the correct translation of the localized strings for the java settings
+    if (translator->load(
+            aTranslationFileName + "_" + QLocale::system().name(),
+            QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
+    {
+        mTranslators.append(translator);
+        qApp->installTranslator(translator);
+    }
+    else
+    {
+        delete translator;
+        translator = NULL;
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::readFromStorage(JavaApplicationSettings& aSettings)
+{
+    if (aSettings.getColumnName().size() > 0
+            && aSettings.getTableName().size() > 0)
+    {
+        wstring value = L"";
+
+        JavaStorageApplicationEntry_t query;
+        JavaStorageApplicationList_t queryResult;
+        JavaStorageEntry attr;
+        attr.setEntry(ID, mSuiteUid);
+        query.insert(attr);
+        if (aSettings.getFilterColumnName().size() > 0)
+        {
+            attr.setEntry(aSettings.getFilterColumnName(), aSettings.getFilterColumnValue());
+            query.insert(attr);
+        }
+        attr.setEntry(aSettings.getColumnName(), L"");
+        query.insert(attr);
+        if (aSettings.getValuesColumnName().size() > 0)
+        {
+            attr.setEntry(aSettings.getValuesColumnName(), L"");
+            query.insert(attr);
+        }
+
+        try
+        {
+            mStorage->search(aSettings.getTableName(), query, queryResult);
+        }
+        catch (JavaStorageException& aJse)
+        {
+            // Don't leave. Set defaults.
+            ELOG1(EJavaSettings, "Error while reading from storage %S", aJse.toString().c_str());
+        }
+
+        if (aSettings.getValuesColumnName().size() > 0)
+        {
+            findEntry(queryResult, aSettings.getValuesColumnName(), value);
+            if (value.size() > 0)
+            {
+                aSettings.setStorageValuesFilter(value);
+                filterSecuritySettings(aSettings);
+            }
+        }
+
+        value = L"";
+        findEntry(queryResult, aSettings.getColumnName(), value);
+
+        if (value.size() > 0)
+        {
+            vector<wstring> storageValues = aSettings.getStorageValues();
+            for (int i=0; i<storageValues.size(); i++)
+            {
+                if (storageValues[i] == value)
+                {
+                    aSettings.setCurrentValue(i);
+                    break;
+                }
+            }
+            LOG2(EJavaSettings, EInfo,"Setting \"%S\" initialized to \"%S\"", aSettings.getName().toStdWString().c_str(), aSettings.getValue(aSettings.getCurrentValue()).toStdWString().c_str());
+        }
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::filterSecuritySettings(JavaApplicationSettings& aSettings)
+{
+    std::wstring allowedModes = aSettings.getStorageValuesFilter();
+    if (allowedModes.size() <= 0)
+    {
+            return;
+    }
+    // The allowed modes info is stored as a 4-bit constant:
+    //    X(oneshot)X(session)X(blanket)X(no)
+    // e.g. 1011 (=11) means that oneshot, blanket and no are allowed.
+    // The following constants are used to encode/decode the allowed modes
+    // into/from a 4-bit number
+    int INTERACTION_MODE_DENIED = 1;
+    int INTERACTION_MODE_BLANKET = 2;
+    int INTERACTION_MODE_SESSION = 4;
+    int INTERACTION_MODE_ONESHOT = 8;
+    TInt allowedInteractionModes = JavaCommonUtils::wstringToInt(allowedModes);
+    int index = 0;
+    int tmp = allowedInteractionModes & INTERACTION_MODE_ONESHOT;
+    if (tmp <= 0)
+    {
+        aSettings.removeValue(index);
+        index--;
+    }
+    index++;
+    tmp = allowedInteractionModes & INTERACTION_MODE_SESSION;
+    if (tmp <= 0)
+    {
+        aSettings.removeValue(index);
+        index--;
+    }
+    index++;
+    tmp = allowedInteractionModes & INTERACTION_MODE_BLANKET;
+    if (tmp <= 0)
+    {
+        aSettings.removeValue(index);
+        index--;
+    }
+    index++;
+    tmp = allowedInteractionModes & INTERACTION_MODE_DENIED;
+    if (tmp <= 0)
+    {
+        aSettings.removeValue(index);
+    }
+}
+
+void JavaApplicationSettingsViewPrivate::writeToStorage(JavaApplicationSettings& aSettings)
+{
+    if (aSettings.getTableName().size() <= 0
+            || aSettings.getColumnName().size() <= 0)
+    {
+        // storage details are not provided -> no point in going further
+        return;
+    }
+    JavaStorageApplicationEntry_t oldEntry;
+    JavaStorageEntry attr;
+    attr.setEntry(ID, mSuiteUid);
+    oldEntry.insert(attr);
+    JavaStorageApplicationEntry_t entry;
+    if (aSettings.getFilterColumnName().size() > 0)
+    {
+        attr.setEntry(aSettings.getFilterColumnName(), aSettings.getFilterColumnValue());
+        oldEntry.insert(attr);
+    }
+    attr.setEntry(aSettings.getColumnName(), aSettings.getStorageValues()[aSettings.getCurrentValue()]);
+    entry.insert(attr);
+
+    try
+    {
+        mStorage->update(aSettings.getTableName(), entry, oldEntry);
+    }
+    catch (JavaStorageException& aJse)
+    {
+        ELOG1(EJavaSettings, "Error while writing into storage %S", aJse.toString().c_str());
+    }
+    LOG2(EJavaSettings, EInfo,"Setting \"%S\" changed to \"%S\"", aSettings.getName().toStdWString().c_str(), aSettings.getValue(aSettings.getCurrentValue()).toStdWString().c_str());
+
+}
+
+void JavaApplicationSettingsViewPrivate::findEntry(const JavaStorageApplicationList_t& aQueryResult,
+        const std::wstring& aName,
+        std::wstring& aValue)
+{
+    if (aQueryResult.size() > 0)
+    {
+        JavaStorageApplicationEntry_t entry = aQueryResult.front();
+        JavaStorageEntry findPattern;
+        findPattern.setEntry(aName, L"");
+        JavaStorageApplicationEntry_t::const_iterator findIterator =
+            entry.find(findPattern);
+        if (findIterator != entry.end())
+        {
+            aValue = findIterator->entryValue();
+        }
+    }
+}
+
+bool JavaApplicationSettingsViewPrivate::isInStorage(const std::wstring& aColumnName, const std::wstring& aColumnFilterName, const std::wstring& aColumnFilterValue, const std::string& aTableName)
+{
+    wstring value = readFromStorage(aColumnName, aColumnFilterName, aColumnFilterValue, aTableName);
+
+    return (value.size() > 0);
+}
+
+wstring JavaApplicationSettingsViewPrivate::readFromStorage(const std::wstring& aColumnName, const std::wstring& aColumnFilterName, const std::wstring& aColumnFilterValue, const std::string& aTableName)
+{
+    wstring value = L"";
+
+    JavaStorageApplicationEntry_t query;
+    JavaStorageApplicationList_t queryResult;
+    JavaStorageEntry attr;
+    attr.setEntry(ID, mSuiteUid);
+    query.insert(attr);
+    if (aColumnFilterName.size() > 0)
+    {
+        attr.setEntry(aColumnFilterName, aColumnFilterValue);
+        query.insert(attr);
+    }
+    attr.setEntry(aColumnName, L"");
+    query.insert(attr);
+
+    try
+    {
+        mStorage->search(aTableName, query, queryResult);
+    }
+    catch (JavaStorageException& aJse)
+    {
+        // Don't leave. Set defaults.
+    }
+
+    findEntry(queryResult, aColumnName, value);
+
+    return value;
+}
+
+vector<IndexedSettingsName> JavaApplicationSettingsViewPrivate::readFromStorage(const std::wstring& aColumnName, const std::string& aPrimaryTableName, const std::string& aSecondaryTableName)
+{
+    vector<IndexedSettingsName> values;
+
+    JavaStorageApplicationEntry_t query;
+    JavaStorageApplicationList_t queryResult;
+    JavaStorageEntry attr;
+    attr.setEntry(ID, mSuiteUid);
+    query.insert(attr);
+    attr.setEntry(aColumnName, L"");
+    query.insert(attr);
+
+    try
+    {
+        mStorage->search(aPrimaryTableName, query, queryResult);
+
+        JavaStorageApplicationList_t::const_iterator iterator;
+        JavaStorageApplicationList_t secondaryQueryResult;
+        for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++)
+        {
+            std::wstring name = L"";
+            JavaStorageApplicationEntry_t entry = (*iterator);
+            JavaStorageEntry findPattern;
+            findPattern.setEntry(aColumnName, L"");
+            JavaStorageApplicationEntry_t::const_iterator findIterator =
+                    entry.find(findPattern);
+            if (findIterator != entry.end())
+            {
+                name = findIterator->entryValue();
+            }
+            if (name.size() > 0)
+            {
+                entry.clear();
+                query.clear();
+                attr.setEntry(ID, mSuiteUid);
+                query.insert(attr);
+                attr.setEntry(aColumnName, name);
+                query.insert(attr);
+                secondaryQueryResult.clear();
+                mStorage->search(aSecondaryTableName, query, secondaryQueryResult);
+                if (secondaryQueryResult.size() > 0)
+                {
+                    IndexedSettingsName value;
+                    value.name = name;
+                    value.index = LAST_SETTINGS_INDEX + 1;
+                    if (mSettingsNamesIndexes.contains(QString::fromStdWString(name)))
+                    {
+                        value.index = mSettingsNamesIndexes.value(QString::fromStdWString(name));
+                    }
+                    values.push_back(value);
+                }
+            }
+        }
+    }
+    catch (JavaStorageException& aJse)
+    {
+        // Don't leave. Set defaults.
+    }
+
+    return values;
+}
+
+void JavaApplicationSettingsViewPrivate::readSuiteUid(const QString& aAppUid)
+{
+    mSuiteUid = L"";
+    bool ok;
+    int tmp = aAppUid.toInt( &ok, 10 );
+    if (!ok)
+    {
+        return;
+    }
+    wstring appUid = L"";
+    appUid.append(L"[").append(QString("%1").arg(tmp, 0, 16).toStdWString()).append(L"]");
+
+    JavaStorageApplicationEntry_t query;
+    JavaStorageApplicationList_t queryResult;
+    JavaStorageEntry attr;
+    attr.setEntry(ID, appUid);
+    query.insert(attr);
+    attr.setEntry(PACKAGE_ID, L"");
+    query.insert(attr);
+    try
+    {
+        mStorage->search(APPLICATION_TABLE, query, queryResult);
+    }
+    catch (JavaStorageException& aJse)
+    {
+        // Don't leave. Set defaults.
+        ELOG1(EJavaSettings, "Error while reading from storage %S", aJse.toString().c_str());
+    }
+    findEntry(queryResult, PACKAGE_ID, mSuiteUid);
+}
+
+#include "moc_javaapplicationsettingsview.cpp"