wlanutilities/wlanwizard/src/wlanwizard_p.cpp
author hgs
Thu, 24 Jun 2010 10:49:51 +0300
changeset 39 7b3e49e4608a
parent 31 e8f4211554fb
child 43 72ebcbb64834
permissions -rw-r--r--
201025
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
31
hgs
parents:
diff changeset
     1
/*
hgs
parents:
diff changeset
     2
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description: 
hgs
parents:
diff changeset
    15
* WLAN Wizard: Private implementation.
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
hgs
parents:
diff changeset
    18
// System includes
hgs
parents:
diff changeset
    19
#include <QLocale>
hgs
parents:
diff changeset
    20
#include <QApplication>
hgs
parents:
diff changeset
    21
#include <QGraphicsWidget>
hgs
parents:
diff changeset
    22
#include <QTimer>
hgs
parents:
diff changeset
    23
#include <QDebug>
hgs
parents:
diff changeset
    24
#include <HbTranslator>
hgs
parents:
diff changeset
    25
#include <HbDocumentLoader>
hgs
parents:
diff changeset
    26
#include <HbMainWindow>
hgs
parents:
diff changeset
    27
#include <HbDialog>
hgs
parents:
diff changeset
    28
#include <HbStackedWidget>
hgs
parents:
diff changeset
    29
#include <HbLabel>
hgs
parents:
diff changeset
    30
#include <HbAction>
hgs
parents:
diff changeset
    31
#include <HbStyleLoader>
hgs
parents:
diff changeset
    32
hgs
parents:
diff changeset
    33
// User includes
hgs
parents:
diff changeset
    34
#include "eapwizard.h"
hgs
parents:
diff changeset
    35
#include "wpswizard.h"
hgs
parents:
diff changeset
    36
#include "wlanqtutils.h"
hgs
parents:
diff changeset
    37
#include "wlanqtutilsap.h"
hgs
parents:
diff changeset
    38
#include "wlanwizardplugin.h"
hgs
parents:
diff changeset
    39
#include "wlanwizard.h"
hgs
parents:
diff changeset
    40
#include "wlanwizard_p.h"
hgs
parents:
diff changeset
    41
#include "wlanwizardutils.h"
hgs
parents:
diff changeset
    42
#include "wlanwizardpagekeyquery.h"
hgs
parents:
diff changeset
    43
#include "wlanwizardpagesummary.h"
hgs
parents:
diff changeset
    44
#include "wlanwizardpageprocessingsettings.h"
hgs
parents:
diff changeset
    45
#include "wlanwizardpagegenericerror.h"
hgs
parents:
diff changeset
    46
#include "wlanwizardpagessid.h"
hgs
parents:
diff changeset
    47
#include "wlanwizardpagenetworkmode.h"
hgs
parents:
diff changeset
    48
#include "wlanwizardpagescanning.h"
hgs
parents:
diff changeset
    49
#include "wlanwizardpagesecuritymode.h"
hgs
parents:
diff changeset
    50
hgs
parents:
diff changeset
    51
#include "OstTraceDefinitions.h"
hgs
parents:
diff changeset
    52
#ifdef OST_TRACE_COMPILER_IN_USE
hgs
parents:
diff changeset
    53
#include "wlanwizard_pTraces.h"
hgs
parents:
diff changeset
    54
#endif
hgs
parents:
diff changeset
    55
hgs
parents:
diff changeset
    56
/*!
hgs
parents:
diff changeset
    57
   \class WlanWizardPrivate
hgs
parents:
diff changeset
    58
   \brief Private implementation of WlanWizard. Implements the interface
hgs
parents:
diff changeset
    59
   WlanWizardHelper to the wizard plugins. 
hgs
parents:
diff changeset
    60
 */
hgs
parents:
diff changeset
    61
hgs
parents:
diff changeset
    62
// External function prototypes
hgs
parents:
diff changeset
    63
hgs
parents:
diff changeset
    64
// Local constants
hgs
parents:
diff changeset
    65
hgs
parents:
diff changeset
    66
/*!
hgs
parents:
diff changeset
    67
   \var PageTimeout Timeout for timer protected pages. 1.5sec
hgs
parents:
diff changeset
    68
 */
hgs
parents:
diff changeset
    69
hgs
parents:
diff changeset
    70
// ======== LOCAL FUNCTIONS ========
hgs
parents:
diff changeset
    71
hgs
parents:
diff changeset
    72
// ======== MEMBER FUNCTIONS ========
hgs
parents:
diff changeset
    73
hgs
parents:
diff changeset
    74
/*!
hgs
parents:
diff changeset
    75
   Constructor of private implementation.
hgs
parents:
diff changeset
    76
   
hgs
parents:
diff changeset
    77
   @param [in] wizard Pointer to the API class.
hgs
parents:
diff changeset
    78
   @param [in] mainWindow pointer to mainwindow.
hgs
parents:
diff changeset
    79
 */
hgs
parents:
diff changeset
    80
WlanWizardPrivate::WlanWizardPrivate(
hgs
parents:
diff changeset
    81
    WlanWizard* wizard, 
hgs
parents:
diff changeset
    82
    HbMainWindow *mainWindow) :
hgs
parents:
diff changeset
    83
    QObject(wizard),
hgs
parents:
diff changeset
    84
    q_ptr(wizard), 
hgs
parents:
diff changeset
    85
    mMainWindow(mainWindow), 
hgs
parents:
diff changeset
    86
    mPageTimer(new QTimer(this)),
hgs
parents:
diff changeset
    87
    mTitle(NULL),
hgs
parents:
diff changeset
    88
    mActionNext(NULL),
hgs
parents:
diff changeset
    89
    mActionPrevious(NULL),
hgs
parents:
diff changeset
    90
    mActionFinish(NULL),
hgs
parents:
diff changeset
    91
    mActionCancel(NULL),
hgs
parents:
diff changeset
    92
    mStackedWidget(NULL),
hgs
parents:
diff changeset
    93
    mDialog(NULL),
hgs
parents:
diff changeset
    94
    mTranslator(new HbTranslator("wlanwizard")),
hgs
parents:
diff changeset
    95
    mWlanQtUtils(new WlanQtUtils()),
hgs
parents:
diff changeset
    96
    mDocLoader(new HbDocumentLoader(mainWindow)),
hgs
parents:
diff changeset
    97
    mEapWizard(NULL), 
hgs
parents:
diff changeset
    98
    mWpsWizard(NULL), 
hgs
parents:
diff changeset
    99
    mFirstPageId(WlanWizardPageInternal::PageNone),
hgs
parents:
diff changeset
   100
    mPageFinished(false),
hgs
parents:
diff changeset
   101
    mClosed(false)
hgs
parents:
diff changeset
   102
{
hgs
parents:
diff changeset
   103
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_WLANWIZARDPRIVATE,
hgs
parents:
diff changeset
   104
        "WlanWizardPrivate::WlanWizardPrivate;this=%x", 
hgs
parents:
diff changeset
   105
        this );
hgs
parents:
diff changeset
   106
    
hgs
parents:
diff changeset
   107
    // Set initial values for configurations
hgs
parents:
diff changeset
   108
    setConfiguration(ConfIapId, WlanQtUtils::IapIdNone);
hgs
parents:
diff changeset
   109
    setConfiguration(ConfConnected, false);
hgs
parents:
diff changeset
   110
    setConfiguration(ConfHiddenWlan, false);
hgs
parents:
diff changeset
   111
    setConfiguration(ConfProcessSettings, false);
hgs
parents:
diff changeset
   112
    setConfiguration(ConfIctStatus, false);
hgs
parents:
diff changeset
   113
hgs
parents:
diff changeset
   114
    // Initialize timer for timer protected pages
hgs
parents:
diff changeset
   115
    mPageTimer->setSingleShot(true);
hgs
parents:
diff changeset
   116
hgs
parents:
diff changeset
   117
    // Load the wizard frame (title, content, actions) from docml 
hgs
parents:
diff changeset
   118
    loadDocml();
hgs
parents:
diff changeset
   119
hgs
parents:
diff changeset
   120
    // Creates the control object of the wlan wizard pages. 
hgs
parents:
diff changeset
   121
    createPages();
hgs
parents:
diff changeset
   122
39
hgs
parents: 31
diff changeset
   123
    // EAP Wizard will add wizard pages at construction phase using
hgs
parents: 31
diff changeset
   124
    // WlanWizardHelper::addPage()
hgs
parents: 31
diff changeset
   125
    mEapWizard.reset(new EapWizard(this) );
hgs
parents: 31
diff changeset
   126
hgs
parents: 31
diff changeset
   127
    // WPS Wizard will add wizard pages at construction phase using
hgs
parents: 31
diff changeset
   128
    // WlanWizardHelper::addPage()
hgs
parents: 31
diff changeset
   129
    mWpsWizard.reset(new WpsWizard(this));
hgs
parents: 31
diff changeset
   130
31
hgs
parents:
diff changeset
   131
    // First page is SSID query, unless client sets configurations via
hgs
parents:
diff changeset
   132
    // setParameters(), which decides the first page..
hgs
parents:
diff changeset
   133
    mFirstPageId = WlanWizardPageInternal::PageSsid;
hgs
parents:
diff changeset
   134
hgs
parents:
diff changeset
   135
    OstTraceExt2( TRACE_BORDER, WLANWIZARDPRIVATE_WLANWIZARDPRIVATE_DONE,
hgs
parents:
diff changeset
   136
        "WlanWizardPrivate::WlanWizardPrivate - done;"
hgs
parents:
diff changeset
   137
        "this=%x;mFirstPageId=%{PageIds}",
hgs
parents:
diff changeset
   138
        ( unsigned )this, mFirstPageId );
hgs
parents:
diff changeset
   139
}
hgs
parents:
diff changeset
   140
hgs
parents:
diff changeset
   141
/*!
hgs
parents:
diff changeset
   142
   Destructor.
hgs
parents:
diff changeset
   143
 */
hgs
parents:
diff changeset
   144
WlanWizardPrivate::~WlanWizardPrivate()
hgs
parents:
diff changeset
   145
{
hgs
parents:
diff changeset
   146
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_DWLANWIZARDPRIVATE,
hgs
parents:
diff changeset
   147
        "WlanWizardPrivate::~WlanWizardPrivate;this=%x",
hgs
parents:
diff changeset
   148
        this );
hgs
parents:
diff changeset
   149
    
hgs
parents:
diff changeset
   150
    // Remove wizard pages from stackedwidgets, since stackedwidget owns the
hgs
parents:
diff changeset
   151
    // objects and all pages are deleted below. 
hgs
parents:
diff changeset
   152
    while (mStackedWidget->count()) {
hgs
parents:
diff changeset
   153
        mStackedWidget->removeAt(0);
hgs
parents:
diff changeset
   154
    }
hgs
parents:
diff changeset
   155
hgs
parents:
diff changeset
   156
    // Delete UI instances (HbWidget) of pages
hgs
parents:
diff changeset
   157
    QHashIterator<HbWidget*, WlanWizardPage*> i(mPageMapper);
hgs
parents:
diff changeset
   158
    while (i.hasNext()) {
hgs
parents:
diff changeset
   159
        i.next();
hgs
parents:
diff changeset
   160
        delete i.key();
hgs
parents:
diff changeset
   161
    }
hgs
parents:
diff changeset
   162
    mPageMapper.clear();
hgs
parents:
diff changeset
   163
hgs
parents:
diff changeset
   164
    // WlanWizardPage objects are automatically deleted since this is the
hgs
parents:
diff changeset
   165
    // parent of the objects.
hgs
parents:
diff changeset
   166
    mPages.clear();
hgs
parents:
diff changeset
   167
    
hgs
parents:
diff changeset
   168
    // timer is cancelled/deleted automatically when the parent (this) is deleted 
hgs
parents:
diff changeset
   169
    
hgs
parents:
diff changeset
   170
    // TODO: See TSW Error: MTAA-854DK8 and loadDocml()
hgs
parents:
diff changeset
   171
    HbStyleLoader::unregisterFilePath(":/css/custom.css");
hgs
parents:
diff changeset
   172
    
39
hgs
parents: 31
diff changeset
   173
    mDialog->setAttribute( Qt::WA_DeleteOnClose, true );
hgs
parents: 31
diff changeset
   174
    mDialog->close();
hgs
parents: 31
diff changeset
   175
    // Remove the pointer from QScopedPointer to prevent double deallocation
hgs
parents: 31
diff changeset
   176
    mDialog.take();
hgs
parents: 31
diff changeset
   177
    
31
hgs
parents:
diff changeset
   178
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_DWLANWIZARDPRIVATE_DONE,
hgs
parents:
diff changeset
   179
        "WlanWizardPrivate::~WlanWizardPrivate-Done;this=%x",
hgs
parents:
diff changeset
   180
        this );
hgs
parents:
diff changeset
   181
}
hgs
parents:
diff changeset
   182
hgs
parents:
diff changeset
   183
/*!
hgs
parents:
diff changeset
   184
   See WlanWizard::setParameters().
hgs
parents:
diff changeset
   185
 */
hgs
parents:
diff changeset
   186
void WlanWizardPrivate::setParameters(
hgs
parents:
diff changeset
   187
    const QString &ssid, 
hgs
parents:
diff changeset
   188
    int networkMode, 
hgs
parents:
diff changeset
   189
    int securityMode, 
hgs
parents:
diff changeset
   190
    bool usePsk,
hgs
parents:
diff changeset
   191
    bool hidden, 
hgs
parents:
diff changeset
   192
    bool wps)
hgs
parents:
diff changeset
   193
{
hgs
parents:
diff changeset
   194
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_SETPARAMETERS, 
hgs
parents:
diff changeset
   195
        "WlanWizardPrivate::setParameters;this=%x", 
hgs
parents:
diff changeset
   196
        this );
hgs
parents:
diff changeset
   197
    
hgs
parents:
diff changeset
   198
    mFirstPageId = getNextPageId(
hgs
parents:
diff changeset
   199
        ssid, networkMode, securityMode, usePsk, hidden, wps);
hgs
parents:
diff changeset
   200
    
hgs
parents:
diff changeset
   201
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_SETPARAMETERS_DONE, 
hgs
parents:
diff changeset
   202
        "WlanWizardPrivate::setParameters - Done;this=%x", 
hgs
parents:
diff changeset
   203
        this );
hgs
parents:
diff changeset
   204
}
hgs
parents:
diff changeset
   205
hgs
parents:
diff changeset
   206
/*!
hgs
parents:
diff changeset
   207
   See WlanWizard::show().
hgs
parents:
diff changeset
   208
 */
hgs
parents:
diff changeset
   209
void WlanWizardPrivate::show()
hgs
parents:
diff changeset
   210
{
hgs
parents:
diff changeset
   211
    OstTraceExt2( TRACE_BORDER, WLANWIZARDPRIVATE_SHOW,
hgs
parents:
diff changeset
   212
        "WlanWizardPrivate::show;this=%x;mFirstPageId=%{PageIds}", 
hgs
parents:
diff changeset
   213
        ( unsigned )this, mFirstPageId );
hgs
parents:
diff changeset
   214
    
hgs
parents:
diff changeset
   215
    Q_ASSERT(mClosed == false);
hgs
parents:
diff changeset
   216
    showPage(mFirstPageId, false);
hgs
parents:
diff changeset
   217
    mDialog->show();
hgs
parents:
diff changeset
   218
    
hgs
parents:
diff changeset
   219
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_SHOW_DONE,
hgs
parents:
diff changeset
   220
        "WlanWizardPrivate::show - Done;this=%x;",
hgs
parents:
diff changeset
   221
        (unsigned)this );
hgs
parents:
diff changeset
   222
}
hgs
parents:
diff changeset
   223
hgs
parents:
diff changeset
   224
/*!
hgs
parents:
diff changeset
   225
   See WlanWizard::setParameters() for descriptions of parameters.
hgs
parents:
diff changeset
   226
   
hgs
parents:
diff changeset
   227
   Based on the provided parameters next page id is returned.
hgs
parents:
diff changeset
   228
   
hgs
parents:
diff changeset
   229
   @return next page id based on provided configurations.
hgs
parents:
diff changeset
   230
 */
hgs
parents:
diff changeset
   231
int WlanWizardPrivate::getNextPageId(
hgs
parents:
diff changeset
   232
    const QString &ssid, 
hgs
parents:
diff changeset
   233
    int networkMode, 
hgs
parents:
diff changeset
   234
    int securityMode, 
hgs
parents:
diff changeset
   235
    bool usePsk,
hgs
parents:
diff changeset
   236
    bool hidden, 
hgs
parents:
diff changeset
   237
    bool wps)
hgs
parents:
diff changeset
   238
{
hgs
parents:
diff changeset
   239
    setConfiguration(ConfProcessSettings, true);
hgs
parents:
diff changeset
   240
    setConfiguration(ConfSsid, ssid);
hgs
parents:
diff changeset
   241
    setConfiguration(ConfNetworkMode, networkMode);
hgs
parents:
diff changeset
   242
    setConfiguration(ConfSecurityMode, securityMode);
hgs
parents:
diff changeset
   243
    setConfiguration(ConfUsePsk, usePsk);
hgs
parents:
diff changeset
   244
    setConfiguration(ConfHiddenWlan, hidden);
hgs
parents:
diff changeset
   245
hgs
parents:
diff changeset
   246
    OstTrace1( TRACE_NORMAL, WLANWIZARDPRIVATE_GETNEXTPAGEID, 
hgs
parents:
diff changeset
   247
        "WlanWizardPrivate::getNextPageId;wps=%u", 
hgs
parents:
diff changeset
   248
        wps );
hgs
parents:
diff changeset
   249
hgs
parents:
diff changeset
   250
    return nextPageId(wps);
hgs
parents:
diff changeset
   251
}
hgs
parents:
diff changeset
   252
hgs
parents:
diff changeset
   253
/*!
hgs
parents:
diff changeset
   254
   Utility method for WLAN Wizard pages to query the wlanqtutils class.
hgs
parents:
diff changeset
   255
   
hgs
parents:
diff changeset
   256
   @return a valid pointer to WlanQtUtils class.
hgs
parents:
diff changeset
   257
 */
hgs
parents:
diff changeset
   258
WlanQtUtils* WlanWizardPrivate::wlanQtUtils() const
hgs
parents:
diff changeset
   259
{
hgs
parents:
diff changeset
   260
    Q_ASSERT(mWlanQtUtils);
hgs
parents:
diff changeset
   261
    return mWlanQtUtils.data();
hgs
parents:
diff changeset
   262
}
hgs
parents:
diff changeset
   263
hgs
parents:
diff changeset
   264
/*!
hgs
parents:
diff changeset
   265
   Utility method for WLAN Wizard pages to query active wizard plugin object
hgs
parents:
diff changeset
   266
   
hgs
parents:
diff changeset
   267
   @return NULL in case plugin is not active.
hgs
parents:
diff changeset
   268
 */ 
hgs
parents:
diff changeset
   269
WlanWizardPlugin* WlanWizardPrivate::wlanWizardPlugin() const
hgs
parents:
diff changeset
   270
{
hgs
parents:
diff changeset
   271
    WlanWizardPlugin* plugin = NULL;
hgs
parents:
diff changeset
   272
hgs
parents:
diff changeset
   273
    if (isEapEnabled()) {
39
hgs
parents: 31
diff changeset
   274
        plugin = mEapWizard.data();
31
hgs
parents:
diff changeset
   275
        Q_ASSERT(plugin);
hgs
parents:
diff changeset
   276
    }
hgs
parents:
diff changeset
   277
    
hgs
parents:
diff changeset
   278
    OstTrace1( TRACE_NORMAL, WLANWIZARDPRIVATE_WLANWIZARDPLUGIN, 
hgs
parents:
diff changeset
   279
        "WlanWizardPrivate::wlanWizardPlugin;plugin=%x", 
hgs
parents:
diff changeset
   280
        plugin );
hgs
parents:
diff changeset
   281
    
hgs
parents:
diff changeset
   282
    return plugin;
hgs
parents:
diff changeset
   283
}
hgs
parents:
diff changeset
   284
hgs
parents:
diff changeset
   285
/*!
hgs
parents:
diff changeset
   286
   Utility method for WLAN Wizard pages to query if EAP mode is active at the
hgs
parents:
diff changeset
   287
   moment
hgs
parents:
diff changeset
   288
   
hgs
parents:
diff changeset
   289
   @return true in case EAP is currently activated.
hgs
parents:
diff changeset
   290
 */
hgs
parents:
diff changeset
   291
bool WlanWizardPrivate::isEapEnabled() const
hgs
parents:
diff changeset
   292
{
hgs
parents:
diff changeset
   293
    bool ret = false;
hgs
parents:
diff changeset
   294
    int secMode = configuration(ConfSecurityMode).toInt();
hgs
parents:
diff changeset
   295
hgs
parents:
diff changeset
   296
    if (((secMode == CMManagerShim::WlanSecModeWpa || 
hgs
parents:
diff changeset
   297
          secMode == CMManagerShim::WlanSecModeWpa2) && 
hgs
parents:
diff changeset
   298
          !configuration(ConfUsePsk).toBool()) || 
hgs
parents:
diff changeset
   299
        secMode == CMManagerShim::WlanSecMode802_1x) {
hgs
parents:
diff changeset
   300
        ret = true;
hgs
parents:
diff changeset
   301
    }
hgs
parents:
diff changeset
   302
hgs
parents:
diff changeset
   303
    OstTrace1( TRACE_NORMAL, WLANWIZARDPRIVATE_ISEAPENABLED, 
hgs
parents:
diff changeset
   304
        "WlanWizardPrivate::isEapEnabled;ret=%u", 
hgs
parents:
diff changeset
   305
        ret );
hgs
parents:
diff changeset
   306
    
hgs
parents:
diff changeset
   307
    return ret;
hgs
parents:
diff changeset
   308
}
hgs
parents:
diff changeset
   309
hgs
parents:
diff changeset
   310
/*!
hgs
parents:
diff changeset
   311
   Creates new iap or updates existing iap.
hgs
parents:
diff changeset
   312
   
hgs
parents:
diff changeset
   313
   @return false in case IAP creation/update failed.
hgs
parents:
diff changeset
   314
 */
hgs
parents:
diff changeset
   315
bool WlanWizardPrivate::handleIap()
hgs
parents:
diff changeset
   316
{
hgs
parents:
diff changeset
   317
    OstTrace0( TRACE_FLOW, WLANWIZARDPRIVATE_HANDLEIAP,
hgs
parents:
diff changeset
   318
        "WlanWizardPrivate::handleIap" );
hgs
parents:
diff changeset
   319
    
hgs
parents:
diff changeset
   320
    bool ret = true;
hgs
parents:
diff changeset
   321
    bool usePsk = true;
hgs
parents:
diff changeset
   322
    int securityMode = configuration(ConfSecurityMode).toInt();
hgs
parents:
diff changeset
   323
    WlanQtUtilsAp wlanAp;
hgs
parents:
diff changeset
   324
   
39
hgs
parents: 31
diff changeset
   325
    // Set default values
hgs
parents: 31
diff changeset
   326
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWpaPsk, QString());
hgs
parents: 31
diff changeset
   327
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWpaPskUse, true );
hgs
parents: 31
diff changeset
   328
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWepDefaultIndex, CMManagerShim::WepKeyIndex1 );
hgs
parents: 31
diff changeset
   329
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey1, QString());
hgs
parents: 31
diff changeset
   330
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey2, QString());
hgs
parents: 31
diff changeset
   331
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey3, QString());
hgs
parents: 31
diff changeset
   332
    wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey4, QString());
hgs
parents: 31
diff changeset
   333
    
31
hgs
parents:
diff changeset
   334
    // Set configuration
hgs
parents:
diff changeset
   335
    wlanAp.setValue(WlanQtUtilsAp::ConfIdSsid, configuration(ConfSsid));
hgs
parents:
diff changeset
   336
    wlanAp.setValue(WlanQtUtilsAp::ConfIdConnectionMode, 
hgs
parents:
diff changeset
   337
        configuration(ConfNetworkMode));
hgs
parents:
diff changeset
   338
    wlanAp.setValue(WlanQtUtilsAp::ConfIdSecurityMode, securityMode );
hgs
parents:
diff changeset
   339
    wlanAp.setValue(WlanQtUtilsAp::ConfIdHidden, configuration(ConfHiddenWlan));
hgs
parents:
diff changeset
   340
    
hgs
parents:
diff changeset
   341
    switch (securityMode) {
hgs
parents:
diff changeset
   342
    case CMManagerShim::WlanSecModeWep:
hgs
parents:
diff changeset
   343
        wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey1, configuration(ConfKeyWep1));
hgs
parents:
diff changeset
   344
        wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey2, configuration(ConfKeyWep2));
hgs
parents:
diff changeset
   345
        wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey3, configuration(ConfKeyWep3));
hgs
parents:
diff changeset
   346
        wlanAp.setValue(WlanQtUtilsAp::ConfIdWepKey4, configuration(ConfKeyWep4));
hgs
parents:
diff changeset
   347
        wlanAp.setValue(
hgs
parents:
diff changeset
   348
            WlanQtUtilsAp::ConfIdWepDefaultIndex,
hgs
parents:
diff changeset
   349
            configuration(ConfKeyWepDefault));
hgs
parents:
diff changeset
   350
        break;
hgs
parents:
diff changeset
   351
hgs
parents:
diff changeset
   352
    case CMManagerShim::WlanSecModeWpa:
hgs
parents:
diff changeset
   353
    case CMManagerShim::WlanSecModeWpa2:
hgs
parents:
diff changeset
   354
        usePsk = configuration(ConfUsePsk).toBool();
hgs
parents:
diff changeset
   355
        wlanAp.setValue(WlanQtUtilsAp::ConfIdWpaPskUse, usePsk);
hgs
parents:
diff changeset
   356
        if (usePsk){
hgs
parents:
diff changeset
   357
            wlanAp.setValue(WlanQtUtilsAp::ConfIdWpaPsk, configuration(ConfKeyWpa));
hgs
parents:
diff changeset
   358
        }
hgs
parents:
diff changeset
   359
        break;
hgs
parents:
diff changeset
   360
    
hgs
parents:
diff changeset
   361
    default:
hgs
parents:
diff changeset
   362
        Q_ASSERT(securityMode == CMManagerShim::WlanSecModeOpen ||
hgs
parents:
diff changeset
   363
            securityMode == CMManagerShim::WlanSecMode802_1x);
hgs
parents:
diff changeset
   364
        // No WLAN Specific configuration
hgs
parents:
diff changeset
   365
        break;
hgs
parents:
diff changeset
   366
    }
hgs
parents:
diff changeset
   367
    
hgs
parents:
diff changeset
   368
    // Create IAP if does not exists or update the existing IAP
hgs
parents:
diff changeset
   369
    int referenceId = configuration(ConfIapId).toInt();
hgs
parents:
diff changeset
   370
    if (referenceId == WlanQtUtils::IapIdNone) {
hgs
parents:
diff changeset
   371
        OstTrace0( TRACE_FLOW, WLANWIZARDPRIVATE_HANDLEIAP_CREATE, 
hgs
parents:
diff changeset
   372
            "WlanWizardPrivate::handleIap: Create IAP" );
hgs
parents:
diff changeset
   373
        
hgs
parents:
diff changeset
   374
        referenceId = mWlanQtUtils->createIap(&wlanAp);
hgs
parents:
diff changeset
   375
        setConfiguration(ConfIapId, referenceId);
hgs
parents:
diff changeset
   376
        
hgs
parents:
diff changeset
   377
        if (referenceId == WlanQtUtils::IapIdNone) {
hgs
parents:
diff changeset
   378
            ret = false;
hgs
parents:
diff changeset
   379
        }
hgs
parents:
diff changeset
   380
    } else {
hgs
parents:
diff changeset
   381
        OstTrace0( TRACE_FLOW, WLANWIZARDPRIVATE_HANDLEIAP_UPDATE, 
hgs
parents:
diff changeset
   382
            "WlanWizardPrivate::handleIap: Update IAP" );
hgs
parents:
diff changeset
   383
hgs
parents:
diff changeset
   384
        ret = mWlanQtUtils->updateIap(referenceId, &wlanAp);
hgs
parents:
diff changeset
   385
    }
hgs
parents:
diff changeset
   386
   
hgs
parents:
diff changeset
   387
    if (ret) {
hgs
parents:
diff changeset
   388
        // Store Wizard plugin specific settings here.
hgs
parents:
diff changeset
   389
        WlanWizardPlugin* plugin = wlanWizardPlugin();
hgs
parents:
diff changeset
   390
        if (plugin) {
hgs
parents:
diff changeset
   391
            OstTrace0( TRACE_FLOW, WLANWIZARDPRIVATE_HANDLEIAP_PLUGIN, 
hgs
parents:
diff changeset
   392
                "WlanWizardPrivate::handleIap: Plugin" );
hgs
parents:
diff changeset
   393
            // Plugin gets the IAP ID from configuration
hgs
parents:
diff changeset
   394
            ret = plugin->storeSettings();
hgs
parents:
diff changeset
   395
        }
hgs
parents:
diff changeset
   396
    }
hgs
parents:
diff changeset
   397
    
hgs
parents:
diff changeset
   398
    OstTrace1( TRACE_FLOW, WLANWIZARDPRIVATE_HANDLEIAP_DONE,
hgs
parents:
diff changeset
   399
        "WlanWizardPrivate::handleIap: Done;ret=%d",
hgs
parents:
diff changeset
   400
        ret );
hgs
parents:
diff changeset
   401
    
hgs
parents:
diff changeset
   402
    return ret;
hgs
parents:
diff changeset
   403
}
hgs
parents:
diff changeset
   404
hgs
parents:
diff changeset
   405
/*!
hgs
parents:
diff changeset
   406
   See WlanWizardHelper::configuration().
hgs
parents:
diff changeset
   407
 */
hgs
parents:
diff changeset
   408
QVariant WlanWizardPrivate::configuration(ConfigurationId confId) const
hgs
parents:
diff changeset
   409
{
hgs
parents:
diff changeset
   410
    Q_ASSERT(mConfigurations.contains(confId));
hgs
parents:
diff changeset
   411
hgs
parents:
diff changeset
   412
#ifdef OST_TRACE_COMPILER_IN_USE
hgs
parents:
diff changeset
   413
    QString tmp;
hgs
parents:
diff changeset
   414
    QDebug tmpStream(&tmp);
hgs
parents:
diff changeset
   415
    tmpStream << mConfigurations[confId];
hgs
parents:
diff changeset
   416
    TPtrC16 string( tmp.utf16(), tmp.length() );
hgs
parents:
diff changeset
   417
    
hgs
parents:
diff changeset
   418
    OstTraceExt2( TRACE_NORMAL, WLANWIZARDPRIVATE_CONFIGURATIONS, 
hgs
parents:
diff changeset
   419
        "WlanWizardPrivate::configuration;confId=%{ConfigurationId};string=%S", 
hgs
parents:
diff changeset
   420
        (uint)confId, string );
hgs
parents:
diff changeset
   421
#endif
hgs
parents:
diff changeset
   422
    
hgs
parents:
diff changeset
   423
    return mConfigurations[confId];
hgs
parents:
diff changeset
   424
}
hgs
parents:
diff changeset
   425
hgs
parents:
diff changeset
   426
/*!
hgs
parents:
diff changeset
   427
   See WlanWizardHelper::setConfiguration().
hgs
parents:
diff changeset
   428
 */
hgs
parents:
diff changeset
   429
void WlanWizardPrivate::setConfiguration(
hgs
parents:
diff changeset
   430
    ConfigurationId confId, 
hgs
parents:
diff changeset
   431
    const QVariant &value)
hgs
parents:
diff changeset
   432
{
hgs
parents:
diff changeset
   433
#ifdef OST_TRACE_COMPILER_IN_USE
hgs
parents:
diff changeset
   434
    QString tmp;
hgs
parents:
diff changeset
   435
    QDebug tmpStream(&tmp);
hgs
parents:
diff changeset
   436
    tmpStream << value;
hgs
parents:
diff changeset
   437
    TPtrC16 string( tmp.utf16(), tmp.length() );
hgs
parents:
diff changeset
   438
    
hgs
parents:
diff changeset
   439
    OstTraceExt2( TRACE_NORMAL, WLANWIZARDPRIVATE_SETCONFIGURATION, 
hgs
parents:
diff changeset
   440
        "WlanWizardPrivate::setConfiguration;"
hgs
parents:
diff changeset
   441
        "confId=%{ConfigurationId};string=%S", 
hgs
parents:
diff changeset
   442
        (uint)confId, string );
hgs
parents:
diff changeset
   443
#endif
hgs
parents:
diff changeset
   444
hgs
parents:
diff changeset
   445
    mConfigurations[confId] = value;
hgs
parents:
diff changeset
   446
}
hgs
parents:
diff changeset
   447
hgs
parents:
diff changeset
   448
/*!
39
hgs
parents: 31
diff changeset
   449
 * See WlanWizardHelper::clearConfiguration().
hgs
parents: 31
diff changeset
   450
 */
hgs
parents: 31
diff changeset
   451
void WlanWizardPrivate::clearConfiguration(ConfigurationId confId)
hgs
parents: 31
diff changeset
   452
{
hgs
parents: 31
diff changeset
   453
    OstTrace1( TRACE_FLOW, WLANWIZARDPRIVATE_CLEARCONFIGURATION,
hgs
parents: 31
diff changeset
   454
        "WlanWizardPrivate::clearConfiguration;confId=%{ConfigurationId}",
hgs
parents: 31
diff changeset
   455
        (uint)confId );
hgs
parents: 31
diff changeset
   456
    
hgs
parents: 31
diff changeset
   457
    mConfigurations.remove(confId);
hgs
parents: 31
diff changeset
   458
}
hgs
parents: 31
diff changeset
   459
hgs
parents: 31
diff changeset
   460
/*!
hgs
parents: 31
diff changeset
   461
 * See WlanWizardHelper::configurationExists().
hgs
parents: 31
diff changeset
   462
 */
hgs
parents: 31
diff changeset
   463
bool WlanWizardPrivate::configurationExists(ConfigurationId confId)
hgs
parents: 31
diff changeset
   464
{
hgs
parents: 31
diff changeset
   465
    OstTrace1( TRACE_DUMP, WLANWIZARDPRIVATE_CONFIGURATIONEXISTS,
hgs
parents: 31
diff changeset
   466
        "WlanWizardPrivate::configurationExists;confId=%{ConfigurationId}",
hgs
parents: 31
diff changeset
   467
        (uint)confId );
hgs
parents: 31
diff changeset
   468
    
hgs
parents: 31
diff changeset
   469
    return mConfigurations[confId].isValid();
hgs
parents: 31
diff changeset
   470
}
hgs
parents: 31
diff changeset
   471
    
hgs
parents: 31
diff changeset
   472
/*!
31
hgs
parents:
diff changeset
   473
   See WlanWizardHelper::enableNextButton().
hgs
parents:
diff changeset
   474
 */
hgs
parents:
diff changeset
   475
void WlanWizardPrivate::enableNextButton(bool enable)
hgs
parents:
diff changeset
   476
{
hgs
parents:
diff changeset
   477
    OstTraceExt2( TRACE_FLOW, WLANWIZARDPRIVATE_ENABLENEXTBUTTON,
hgs
parents:
diff changeset
   478
        "WlanWizardPrivate::enableNextButton;this=%x;enable=%x",
hgs
parents:
diff changeset
   479
        (unsigned)this, (uint)enable );
hgs
parents:
diff changeset
   480
    mActionNext->setEnabled(enable);
hgs
parents:
diff changeset
   481
}
hgs
parents:
diff changeset
   482
hgs
parents:
diff changeset
   483
/*!
hgs
parents:
diff changeset
   484
   See WlanWizardHelper::addPage().
hgs
parents:
diff changeset
   485
 */
hgs
parents:
diff changeset
   486
void WlanWizardPrivate::addPage(int pageId, WlanWizardPage *page)
hgs
parents:
diff changeset
   487
{
hgs
parents:
diff changeset
   488
    OstTraceExt3( TRACE_FLOW, WLANWIZARDPRIVATE_ADDPAGE, 
hgs
parents:
diff changeset
   489
        "WlanWizardPrivate::addPage;this=%x;pageId=%{PageIds};page=%x",
hgs
parents:
diff changeset
   490
        (unsigned)this, pageId, (uint)(page) );
hgs
parents:
diff changeset
   491
hgs
parents:
diff changeset
   492
    Q_ASSERT(!mPages.contains(pageId));
hgs
parents:
diff changeset
   493
    mPages[pageId] = page;
hgs
parents:
diff changeset
   494
}
hgs
parents:
diff changeset
   495
hgs
parents:
diff changeset
   496
/*!
hgs
parents:
diff changeset
   497
   See WlanWizardHelper::nextPage().
hgs
parents:
diff changeset
   498
 */
hgs
parents:
diff changeset
   499
void WlanWizardPrivate::nextPage()
hgs
parents:
diff changeset
   500
{
hgs
parents:
diff changeset
   501
    OstTrace1( TRACE_FLOW, WLANWIZARDPRIVATE_NEXTPAGE,
hgs
parents:
diff changeset
   502
        "WlanWizardPrivate::nextPage;this=%x",
hgs
parents:
diff changeset
   503
        this );
hgs
parents:
diff changeset
   504
    
hgs
parents:
diff changeset
   505
    mPageFinished = true;
hgs
parents:
diff changeset
   506
    toNextPage();
hgs
parents:
diff changeset
   507
}
hgs
parents:
diff changeset
   508
hgs
parents:
diff changeset
   509
/*!
hgs
parents:
diff changeset
   510
   See WlanWizardHelper::mainWindow().
hgs
parents:
diff changeset
   511
 */
hgs
parents:
diff changeset
   512
HbMainWindow* WlanWizardPrivate::mainWindow() const
hgs
parents:
diff changeset
   513
{
hgs
parents:
diff changeset
   514
    return mMainWindow;
hgs
parents:
diff changeset
   515
}
hgs
parents:
diff changeset
   516
hgs
parents:
diff changeset
   517
/*!
hgs
parents:
diff changeset
   518
   See WlanWizardHelper::isCurrentPage().
hgs
parents:
diff changeset
   519
 */
hgs
parents:
diff changeset
   520
bool WlanWizardPrivate::isCurrentPage(const HbWidget *page) const
hgs
parents:
diff changeset
   521
{
hgs
parents:
diff changeset
   522
    bool ret = false;
hgs
parents:
diff changeset
   523
    if (mStackedWidget->currentWidget() == page) {
hgs
parents:
diff changeset
   524
        ret = true;
hgs
parents:
diff changeset
   525
    }
hgs
parents:
diff changeset
   526
    
hgs
parents:
diff changeset
   527
    OstTraceExt2( TRACE_FLOW, WLANWIZARDPRIVATE_ISCURRENTPAGE, 
hgs
parents:
diff changeset
   528
        "WlanWizardPrivate::isCurrentPage;page=%x;ret=%d", 
hgs
parents:
diff changeset
   529
        (uint)page, ret);
hgs
parents:
diff changeset
   530
    
hgs
parents:
diff changeset
   531
    return ret;
hgs
parents:
diff changeset
   532
}
hgs
parents:
diff changeset
   533
hgs
parents:
diff changeset
   534
/*!
hgs
parents:
diff changeset
   535
   See WlanWizardHelper::nextPageId()
hgs
parents:
diff changeset
   536
 */
hgs
parents:
diff changeset
   537
int WlanWizardPrivate::nextPageId(bool useWps)
hgs
parents:
diff changeset
   538
{
hgs
parents:
diff changeset
   539
    int ret;
hgs
parents:
diff changeset
   540
    if (useWps) {
hgs
parents:
diff changeset
   541
        ret = WlanWizardPage::PageWpsStart;
39
hgs
parents: 31
diff changeset
   542
    } else {
hgs
parents: 31
diff changeset
   543
        int secMode = configuration(WlanWizardHelper::ConfSecurityMode).toInt();
hgs
parents: 31
diff changeset
   544
        switch (secMode) {
hgs
parents: 31
diff changeset
   545
        case CMManagerShim::WlanSecModeWep:
hgs
parents: 31
diff changeset
   546
            ret = WlanWizardPageInternal::PageKeyQuery;
hgs
parents: 31
diff changeset
   547
            break;
hgs
parents: 31
diff changeset
   548
            
hgs
parents: 31
diff changeset
   549
        case CMManagerShim::WlanSecModeWpa:
hgs
parents: 31
diff changeset
   550
        case CMManagerShim::WlanSecModeWpa2:
hgs
parents: 31
diff changeset
   551
            if (configuration(WlanWizardHelper::ConfUsePsk).toBool()) {
hgs
parents: 31
diff changeset
   552
                ret = WlanWizardPageInternal::PageKeyQuery;
hgs
parents: 31
diff changeset
   553
            } else {
hgs
parents: 31
diff changeset
   554
                ret = WlanWizardPage::PageEapStart;
hgs
parents: 31
diff changeset
   555
            }
hgs
parents: 31
diff changeset
   556
            break;
hgs
parents: 31
diff changeset
   557
            
hgs
parents: 31
diff changeset
   558
        case CMManagerShim::WlanSecMode802_1x:
hgs
parents: 31
diff changeset
   559
            ret = WlanWizardPage::PageEapStart;
hgs
parents: 31
diff changeset
   560
            break;
hgs
parents: 31
diff changeset
   561
            
hgs
parents: 31
diff changeset
   562
        default:
hgs
parents: 31
diff changeset
   563
            Q_ASSERT(
hgs
parents: 31
diff changeset
   564
                secMode == CMManagerShim::WlanSecModeOpen || 
hgs
parents: 31
diff changeset
   565
                secMode == CMManagerShim::WlanSecModeWapi);
hgs
parents: 31
diff changeset
   566
            
hgs
parents: 31
diff changeset
   567
            setConfiguration(ConfSecurityMode, CMManagerShim::WlanSecModeOpen);
hgs
parents: 31
diff changeset
   568
            ret = WlanWizardPageInternal::PageProcessSettings;
hgs
parents: 31
diff changeset
   569
            break;
hgs
parents: 31
diff changeset
   570
        }
31
hgs
parents:
diff changeset
   571
    }
hgs
parents:
diff changeset
   572
hgs
parents:
diff changeset
   573
    OstTraceExt3( TRACE_NORMAL, WLANWIZARDPRIVATE_NEXTPAGEID,
hgs
parents:
diff changeset
   574
        "WlanWizardPrivate::nextPageId;this=%x;useWps=%x;ret=%{PageIds}",
hgs
parents:
diff changeset
   575
        ( unsigned )this, ( TUint )( useWps ), ret );
hgs
parents:
diff changeset
   576
hgs
parents:
diff changeset
   577
    return ret;
hgs
parents:
diff changeset
   578
}
hgs
parents:
diff changeset
   579
hgs
parents:
diff changeset
   580
/*!
hgs
parents:
diff changeset
   581
   Called when Cancel toolbar button is pressed. In case IAP has been created
hgs
parents:
diff changeset
   582
   it will be disconnected and the IAP settings are deleted and finally the
hgs
parents:
diff changeset
   583
   wizard is closed. 
hgs
parents:
diff changeset
   584
   
hgs
parents:
diff changeset
   585
   Indicates also to the current wizard page that cancel has been pressed.
hgs
parents:
diff changeset
   586
 */
hgs
parents:
diff changeset
   587
void WlanWizardPrivate::cancelTriggered()
hgs
parents:
diff changeset
   588
{
hgs
parents:
diff changeset
   589
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_CANCELTRIGGERED,
hgs
parents:
diff changeset
   590
        "WlanWizardPrivate::cancelTriggered;this=%x",
hgs
parents:
diff changeset
   591
        this );
hgs
parents:
diff changeset
   592
    
hgs
parents:
diff changeset
   593
    // Disconnect receiving more signals from any actions
hgs
parents:
diff changeset
   594
    disconnectActions();
hgs
parents:
diff changeset
   595
    
hgs
parents:
diff changeset
   596
    mPageTimer->stop();
hgs
parents:
diff changeset
   597
hgs
parents:
diff changeset
   598
    HbWidget *widget = qobject_cast<HbWidget*>(mStackedWidget->currentWidget());
hgs
parents:
diff changeset
   599
    Q_ASSERT(widget);
hgs
parents:
diff changeset
   600
    mPageMapper[widget]->cancelTriggered();
hgs
parents:
diff changeset
   601
hgs
parents:
diff changeset
   602
    int referenceId = configuration(ConfIapId).toInt();
hgs
parents:
diff changeset
   603
    if (referenceId != WlanQtUtils::IapIdNone) {
hgs
parents:
diff changeset
   604
        // call disconnect even if
hgs
parents:
diff changeset
   605
        // - connection is not open
hgs
parents:
diff changeset
   606
        // - connection establishment is ongoing
hgs
parents:
diff changeset
   607
        mWlanQtUtils->disconnectIap(referenceId);
hgs
parents:
diff changeset
   608
        
hgs
parents:
diff changeset
   609
        // if IAP deletion fails, there is nothing we can do with it
hgs
parents:
diff changeset
   610
        mWlanQtUtils->deleteIap(referenceId);
hgs
parents:
diff changeset
   611
        setConfiguration(ConfIapId, WlanQtUtils::IapIdNone);
hgs
parents:
diff changeset
   612
    }
hgs
parents:
diff changeset
   613
    closeViews();
hgs
parents:
diff changeset
   614
    Q_ASSERT(q_ptr);
hgs
parents:
diff changeset
   615
hgs
parents:
diff changeset
   616
    OstTrace0( TRACE_BORDER, WLANWIZARDPRIVATE_CANCELTRIGGERED_EMIT,
hgs
parents:
diff changeset
   617
        "WlanWizardPrivate::cancelTriggered - emit cancelled()" );
hgs
parents:
diff changeset
   618
    
hgs
parents:
diff changeset
   619
    emit q_ptr->cancelled();
hgs
parents:
diff changeset
   620
    
hgs
parents:
diff changeset
   621
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_CANCELTRIGGERED_DONE,
hgs
parents:
diff changeset
   622
        "WlanWizardPrivate::cancelTriggered - Done;this=%x", this );
hgs
parents:
diff changeset
   623
}
hgs
parents:
diff changeset
   624
hgs
parents:
diff changeset
   625
/*!
hgs
parents:
diff changeset
   626
   Called when Previous toolbar button is pressed. Shows the previous wizard 
hgs
parents:
diff changeset
   627
   page in stacked widget and indicates wizard page that previous has been 
hgs
parents:
diff changeset
   628
   pressed.
hgs
parents:
diff changeset
   629
 */
hgs
parents:
diff changeset
   630
void WlanWizardPrivate::previousTriggered()
hgs
parents:
diff changeset
   631
{
hgs
parents:
diff changeset
   632
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_PREVIOUSTRIGGERED,
hgs
parents:
diff changeset
   633
        "WlanWizardPrivate::previousTriggered;this=%x",
hgs
parents:
diff changeset
   634
        this );
hgs
parents:
diff changeset
   635
    
hgs
parents:
diff changeset
   636
    mPageTimer->stop();
hgs
parents:
diff changeset
   637
hgs
parents:
diff changeset
   638
    int index = mStackedWidget->currentIndex();
hgs
parents:
diff changeset
   639
    HbWidget *widget = qobject_cast<HbWidget*>(mStackedWidget->currentWidget());
hgs
parents:
diff changeset
   640
    Q_ASSERT(widget);
hgs
parents:
diff changeset
   641
    int back = mPageMapper[widget]->previousTriggered();
hgs
parents:
diff changeset
   642
hgs
parents:
diff changeset
   643
    // check that at least one page is left in the stack
hgs
parents:
diff changeset
   644
    Q_ASSERT( back < mStackedWidget->count());
hgs
parents:
diff changeset
   645
hgs
parents:
diff changeset
   646
    // When a widget which is last in the stack is removed the currentindex
hgs
parents:
diff changeset
   647
    // is automatically updated.
hgs
parents:
diff changeset
   648
    for (int i = 0; i < back; ++i) {
hgs
parents:
diff changeset
   649
        mStackedWidget->removeAt(index - i);
hgs
parents:
diff changeset
   650
    }
hgs
parents:
diff changeset
   651
hgs
parents:
diff changeset
   652
    widget = qobject_cast<HbWidget*> (mStackedWidget->currentWidget());
hgs
parents:
diff changeset
   653
    Q_ASSERT(widget);
hgs
parents:
diff changeset
   654
    WlanWizardPage* page = mPageMapper[widget];
hgs
parents:
diff changeset
   655
    Q_ASSERT(page);
hgs
parents:
diff changeset
   656
    // In error case if page (value) is not found default contructed key is 
hgs
parents:
diff changeset
   657
    // returned, in this case default value for int is 0 which means PageNone.
hgs
parents:
diff changeset
   658
    updateFrame(mPages.key(page));
hgs
parents:
diff changeset
   659
    enableNextButton(page->showPage());
hgs
parents:
diff changeset
   660
    
hgs
parents:
diff changeset
   661
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_PREVIOUSTRIGGERED_DONE,
hgs
parents:
diff changeset
   662
        "WlanWizardPrivate::previousTriggered - Done;this=%x",
hgs
parents:
diff changeset
   663
        this );
hgs
parents:
diff changeset
   664
}
hgs
parents:
diff changeset
   665
hgs
parents:
diff changeset
   666
/*!
hgs
parents:
diff changeset
   667
   Next toolbar button has been pressed. Wizard framework asks from the current
hgs
parents:
diff changeset
   668
   page what should be the next page id and shows it.
hgs
parents:
diff changeset
   669
 */
hgs
parents:
diff changeset
   670
void WlanWizardPrivate::nextTriggered()
hgs
parents:
diff changeset
   671
{
hgs
parents:
diff changeset
   672
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_NEXTTRIGGERED,
hgs
parents:
diff changeset
   673
        "WlanWizardPrivate::nextTriggered;this=%x",
hgs
parents:
diff changeset
   674
        this );
hgs
parents:
diff changeset
   675
    
hgs
parents:
diff changeset
   676
    mPageTimer->stop();
hgs
parents:
diff changeset
   677
hgs
parents:
diff changeset
   678
    HbWidget *widget = qobject_cast<HbWidget*>(mStackedWidget->currentWidget());
hgs
parents:
diff changeset
   679
    Q_ASSERT(widget);
hgs
parents:
diff changeset
   680
hgs
parents:
diff changeset
   681
    bool removeFromStack;
hgs
parents:
diff changeset
   682
    int pageId = mPageMapper[widget]->nextId(removeFromStack);
hgs
parents:
diff changeset
   683
    showPage(pageId, removeFromStack);
hgs
parents:
diff changeset
   684
    
hgs
parents:
diff changeset
   685
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_NEXTTRIGGERED_DONE,
hgs
parents:
diff changeset
   686
        "WlanWizardPrivate::nextTriggered - Done;this=%x",
hgs
parents:
diff changeset
   687
        this );
hgs
parents:
diff changeset
   688
}
hgs
parents:
diff changeset
   689
hgs
parents:
diff changeset
   690
/*!
hgs
parents:
diff changeset
   691
   Finish button has been pressed. Closes the wizard and sends finished()
hgs
parents:
diff changeset
   692
   signal to the client. 
hgs
parents:
diff changeset
   693
 */
hgs
parents:
diff changeset
   694
void WlanWizardPrivate::finishTriggered()
hgs
parents:
diff changeset
   695
{
hgs
parents:
diff changeset
   696
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_FINISHTRIGGERED,
hgs
parents:
diff changeset
   697
        "WlanWizardPrivate::finishTriggered;this=%x",
hgs
parents:
diff changeset
   698
        this );
hgs
parents:
diff changeset
   699
    
hgs
parents:
diff changeset
   700
    // Disconnect receiving more signals from any actions
hgs
parents:
diff changeset
   701
    disconnectActions();
hgs
parents:
diff changeset
   702
    
hgs
parents:
diff changeset
   703
    mPageTimer->stop();
hgs
parents:
diff changeset
   704
    closeViews();
hgs
parents:
diff changeset
   705
hgs
parents:
diff changeset
   706
    Q_ASSERT(q_ptr);
hgs
parents:
diff changeset
   707
    emit q_ptr->finished(
hgs
parents:
diff changeset
   708
        configuration(ConfIapId).toInt(), 
hgs
parents:
diff changeset
   709
        configuration(ConfConnected).toBool());
hgs
parents:
diff changeset
   710
    
hgs
parents:
diff changeset
   711
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_FINISHTRIGGERED_DONE,
hgs
parents:
diff changeset
   712
        "WlanWizardPrivate::finishTriggered - Done;this=%x",
hgs
parents:
diff changeset
   713
        this );
hgs
parents:
diff changeset
   714
}
hgs
parents:
diff changeset
   715
hgs
parents:
diff changeset
   716
/*!
hgs
parents:
diff changeset
   717
   In case wizard page is using timer protection for the page, this is the
hgs
parents:
diff changeset
   718
   slot to handle the callback from the timer.
hgs
parents:
diff changeset
   719
 */
hgs
parents:
diff changeset
   720
void WlanWizardPrivate::onTimeOut()
hgs
parents:
diff changeset
   721
{
hgs
parents:
diff changeset
   722
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_ONTIMEOUT,
hgs
parents:
diff changeset
   723
        "WlanWizardPrivate::onTimeOut;this=%x",
hgs
parents:
diff changeset
   724
        this );
hgs
parents:
diff changeset
   725
    
hgs
parents:
diff changeset
   726
    toNextPage();
hgs
parents:
diff changeset
   727
    
hgs
parents:
diff changeset
   728
    OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_ONTIMEOUT_DONE,
hgs
parents:
diff changeset
   729
        "WlanWizardPrivate::onTimeOut - Done;this=%x",
hgs
parents:
diff changeset
   730
        this );
hgs
parents:
diff changeset
   731
}
hgs
parents:
diff changeset
   732
hgs
parents:
diff changeset
   733
/*!
hgs
parents:
diff changeset
   734
   Slot to start wizard page operation asynchronous. Starts also the timer
hgs
parents:
diff changeset
   735
   to protect the wizard page.
hgs
parents:
diff changeset
   736
 */
hgs
parents:
diff changeset
   737
void WlanWizardPrivate::startPageOperation()
hgs
parents:
diff changeset
   738
{
hgs
parents:
diff changeset
   739
    // Process this if wizard has not been closed
hgs
parents:
diff changeset
   740
    if (mClosed == false) {
hgs
parents:
diff changeset
   741
        OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_STARTPAGEOPERATION,
hgs
parents:
diff changeset
   742
            "WlanWizardPrivate::startPageOperation;this=%x",
hgs
parents:
diff changeset
   743
            this );
hgs
parents:
diff changeset
   744
        
hgs
parents:
diff changeset
   745
        HbWidget *widget = 
hgs
parents:
diff changeset
   746
            qobject_cast<HbWidget*>(mStackedWidget->currentWidget());
hgs
parents:
diff changeset
   747
        Q_ASSERT(widget);
hgs
parents:
diff changeset
   748
        mPageFinished = false;
hgs
parents:
diff changeset
   749
        mPageTimer->start(PageTimeout);
hgs
parents:
diff changeset
   750
        mPageMapper[widget]->startOperation();
hgs
parents:
diff changeset
   751
        
hgs
parents:
diff changeset
   752
        OstTrace1( TRACE_BORDER, WLANWIZARDPRIVATE_STARTPAGEOPERATION_DONE,
hgs
parents:
diff changeset
   753
            "WlanWizardPrivate::startPageOperation - DONE;this=%x",
hgs
parents:
diff changeset
   754
            this );
hgs
parents:
diff changeset
   755
    }
hgs
parents:
diff changeset
   756
}
hgs
parents:
diff changeset
   757
hgs
parents:
diff changeset
   758
/*!
hgs
parents:
diff changeset
   759
   In case the wizard page uses timer protection this method determines when
hgs
parents:
diff changeset
   760
   the next page is shown.
hgs
parents:
diff changeset
   761
 */
hgs
parents:
diff changeset
   762
void WlanWizardPrivate::toNextPage()
hgs
parents:
diff changeset
   763
{
hgs
parents:
diff changeset
   764
    if (mPageFinished && !(mPageTimer->isActive())) {
hgs
parents:
diff changeset
   765
        OstTrace1( TRACE_FLOW, WLANWIZARDPRIVATE_TONEXTPAGE,
hgs
parents:
diff changeset
   766
            "WlanWizardPrivate::toNextPage;this=%x",
hgs
parents:
diff changeset
   767
            this );
hgs
parents:
diff changeset
   768
        
hgs
parents:
diff changeset
   769
        // process this asynchronous. Main purpose is to release the current
hgs
parents:
diff changeset
   770
        // call stack and process the page change using new call stack
hgs
parents:
diff changeset
   771
        QMetaObject::invokeMethod(this, "nextTriggered", Qt::QueuedConnection);
hgs
parents:
diff changeset
   772
    }
hgs
parents:
diff changeset
   773
}
hgs
parents:
diff changeset
   774
hgs
parents:
diff changeset
   775
/*!
hgs
parents:
diff changeset
   776
   Show requested page and removes the current wizard page from the stack if
hgs
parents:
diff changeset
   777
   required. This method updates the title and toolbar accordingly.
hgs
parents:
diff changeset
   778
   
hgs
parents:
diff changeset
   779
   See WlanWizardPage::nextId()
hgs
parents:
diff changeset
   780
   
hgs
parents:
diff changeset
   781
   @param [in] pageId Wizard Page ID to be shown
hgs
parents:
diff changeset
   782
   @param [in] removeFromStack if true the current wizard page is removed from
hgs
parents:
diff changeset
   783
                               the stackedwidget. 
hgs
parents:
diff changeset
   784
 */
hgs
parents:
diff changeset
   785
void WlanWizardPrivate::showPage(int pageId, bool removeFromStack)
hgs
parents:
diff changeset
   786
{
hgs
parents:
diff changeset
   787
    OstTraceExt3( TRACE_FLOW, WLANWIZARDPRIVATE_SHOWPAGE,
hgs
parents:
diff changeset
   788
        "WlanWizardPrivate::showPage;this=%x;"
hgs
parents:
diff changeset
   789
        "pageId=%{PageIds};removeFromStack=%x",
hgs
parents:
diff changeset
   790
        ( unsigned )this, pageId, ( TUint )( removeFromStack ) );
hgs
parents:
diff changeset
   791
    
hgs
parents:
diff changeset
   792
    // PageNone is returned by wizard pages when some validation of page content
hgs
parents:
diff changeset
   793
    // has not passed and the page does not want to process wizard to next page
hgs
parents:
diff changeset
   794
    if (pageId == WlanWizardPage::PageNone) {
hgs
parents:
diff changeset
   795
        return;
hgs
parents:
diff changeset
   796
    }
hgs
parents:
diff changeset
   797
    
hgs
parents:
diff changeset
   798
    //  PageProcessSettings is shown only when WLAN AP is found in scanning
hgs
parents:
diff changeset
   799
    // 1/ when client calls setParameters()
hgs
parents:
diff changeset
   800
    // 2/ scanning page has found match with given SSID
hgs
parents:
diff changeset
   801
    if (pageId == WlanWizardPage::PageProcessSettings) {
hgs
parents:
diff changeset
   802
        if (configuration(ConfProcessSettings).toBool() == false) {
hgs
parents:
diff changeset
   803
            if (handleIap()){
hgs
parents:
diff changeset
   804
                pageId = WlanWizardPageInternal::PageSummary;
hgs
parents:
diff changeset
   805
            } else {
hgs
parents:
diff changeset
   806
                pageId = WlanWizardPage::PageGenericError;
hgs
parents:
diff changeset
   807
                setConfiguration(
hgs
parents:
diff changeset
   808
                    ConfGenericErrorString, 
hgs
parents:
diff changeset
   809
                    hbTrId("txt_occ_dialog_unable_to_save_settings_please_ret"));
39
hgs
parents: 31
diff changeset
   810
                
hgs
parents: 31
diff changeset
   811
                setConfiguration(
hgs
parents: 31
diff changeset
   812
                    ConfGenericErrorPageStepsBackwards, 
hgs
parents: 31
diff changeset
   813
                    WlanWizardPage::OneStepBackwards);
31
hgs
parents:
diff changeset
   814
            }
hgs
parents:
diff changeset
   815
            OstTraceExt2( TRACE_FLOW, WLANWIZARDPRIVATE_SHOWPAGE_UPDATE,
hgs
parents:
diff changeset
   816
                "WlanWizardPrivate::showPage - change page;this=%x;"
hgs
parents:
diff changeset
   817
                "pageId=%{PageIds}",
hgs
parents:
diff changeset
   818
                ( unsigned )this, pageId);
hgs
parents:
diff changeset
   819
        }
hgs
parents:
diff changeset
   820
    }
hgs
parents:
diff changeset
   821
hgs
parents:
diff changeset
   822
    // Create visualization of next page and store it to mappers
hgs
parents:
diff changeset
   823
    WlanWizardPage* page = mPages[pageId];
hgs
parents:
diff changeset
   824
    Q_ASSERT(page);
hgs
parents:
diff changeset
   825
    HbWidget* widget = page->initializePage();
hgs
parents:
diff changeset
   826
    Q_ASSERT(widget);
hgs
parents:
diff changeset
   827
    mPageMapper[widget] = page;
hgs
parents:
diff changeset
   828
hgs
parents:
diff changeset
   829
    // index calculation has to be happened before adding new widget into
hgs
parents:
diff changeset
   830
    // the stacked widget. Since the internal implementation of stackedwidget
hgs
parents:
diff changeset
   831
    // sets the first widget in the stack to current widget..
hgs
parents:
diff changeset
   832
    // and when there are not any widgets in the stack the current index is
hgs
parents:
diff changeset
   833
    // -1. Valid index starts from 0.
hgs
parents:
diff changeset
   834
    int index = mStackedWidget->currentIndex();
hgs
parents:
diff changeset
   835
hgs
parents:
diff changeset
   836
    if (removeFromStack) {
hgs
parents:
diff changeset
   837
        // widget is removed from the stacked widget, not deleted
hgs
parents:
diff changeset
   838
        mStackedWidget->removeAt(index);
hgs
parents:
diff changeset
   839
    } else {
hgs
parents:
diff changeset
   840
        index++;
hgs
parents:
diff changeset
   841
    }
hgs
parents:
diff changeset
   842
    mStackedWidget->addWidget(widget);
hgs
parents:
diff changeset
   843
    mStackedWidget->setCurrentIndex(index);
hgs
parents:
diff changeset
   844
    updateFrame(pageId);
hgs
parents:
diff changeset
   845
    enableNextButton(page->showPage());    
hgs
parents:
diff changeset
   846
hgs
parents:
diff changeset
   847
    // If wizard page needs to start some control operation trigger it 
hgs
parents:
diff changeset
   848
    // asyncronously so that the UI gets more priority to get painted correctly
hgs
parents:
diff changeset
   849
    // before any operation takes place in wizard page. This is important for
hgs
parents:
diff changeset
   850
    // timer protected pages. Makes wizard to work smother from UI perspective
hgs
parents:
diff changeset
   851
    if (page->requiresStartOperation()) {
hgs
parents:
diff changeset
   852
        OstTrace0( TRACE_FLOW, WLANWIZARDPRIVATE_SHOWPAGE_INVOKE,
hgs
parents:
diff changeset
   853
            "WlanWizardPrivate::showPage - Invoke startOperation" );
hgs
parents:
diff changeset
   854
        
hgs
parents:
diff changeset
   855
        QMetaObject::invokeMethod(this, "startPageOperation", Qt::QueuedConnection);
hgs
parents:
diff changeset
   856
    }
hgs
parents:
diff changeset
   857
}
hgs
parents:
diff changeset
   858
hgs
parents:
diff changeset
   859
/*!
hgs
parents:
diff changeset
   860
   Creates all control objects of WLAN wizard pages which are inherited from
hgs
parents:
diff changeset
   861
   WlanWizardPage and adds those into a internal database. 
hgs
parents:
diff changeset
   862
 */
hgs
parents:
diff changeset
   863
void WlanWizardPrivate::createPages()
hgs
parents:
diff changeset
   864
{
39
hgs
parents: 31
diff changeset
   865
    OstTrace0(
hgs
parents: 31
diff changeset
   866
        TRACE_NORMAL,
hgs
parents: 31
diff changeset
   867
        WLANWIZARDPRIVATE_CREATEPAGES,
hgs
parents: 31
diff changeset
   868
        "WlanWizardPrivate::createPages");
31
hgs
parents:
diff changeset
   869
    
39
hgs
parents: 31
diff changeset
   870
    addPage(
hgs
parents: 31
diff changeset
   871
        WlanWizardPageInternal::PageKeyQuery, 
31
hgs
parents:
diff changeset
   872
        new WlanWizardPageKeyQuery(this));
hgs
parents:
diff changeset
   873
    
39
hgs
parents: 31
diff changeset
   874
    addPage(
hgs
parents: 31
diff changeset
   875
        WlanWizardPageInternal::PageProcessSettings, 
31
hgs
parents:
diff changeset
   876
        new WlanWizardPageProcessingSettings(this));
hgs
parents:
diff changeset
   877
    
39
hgs
parents: 31
diff changeset
   878
    addPage(
hgs
parents: 31
diff changeset
   879
        WlanWizardPageInternal::PageSummary, 
31
hgs
parents:
diff changeset
   880
        new WlanWizardPageSummary(this));
hgs
parents:
diff changeset
   881
39
hgs
parents: 31
diff changeset
   882
    addPage(
hgs
parents: 31
diff changeset
   883
        WlanWizardPageInternal::PageGenericError, 
31
hgs
parents:
diff changeset
   884
        new WlanWizardPageGenericError(this));
hgs
parents:
diff changeset
   885
    
39
hgs
parents: 31
diff changeset
   886
    addPage(
hgs
parents: 31
diff changeset
   887
        WlanWizardPageInternal::PageSsid,
hgs
parents: 31
diff changeset
   888
        new WlanWizardPageSsid(this));
31
hgs
parents:
diff changeset
   889
    
39
hgs
parents: 31
diff changeset
   890
    addPage(
hgs
parents: 31
diff changeset
   891
        WlanWizardPageInternal::PageScanning, 
31
hgs
parents:
diff changeset
   892
        new WlanWizardPageScanning(this));
hgs
parents:
diff changeset
   893
    
39
hgs
parents: 31
diff changeset
   894
    addPage(
hgs
parents: 31
diff changeset
   895
        WlanWizardPageInternal::PageNetworkMode, 
31
hgs
parents:
diff changeset
   896
        new WlanWizardPageNetworkMode(this));
hgs
parents:
diff changeset
   897
    
39
hgs
parents: 31
diff changeset
   898
    addPage(
hgs
parents: 31
diff changeset
   899
        WlanWizardPageInternal::PageNetworkSecurity, 
31
hgs
parents:
diff changeset
   900
        new WlanWizardPageSecurityMode(this));
hgs
parents:
diff changeset
   901
}
hgs
parents:
diff changeset
   902
hgs
parents:
diff changeset
   903
/*!
hgs
parents:
diff changeset
   904
   Called when wizard is closed 
hgs
parents:
diff changeset
   905
   - cancelled by the user
hgs
parents:
diff changeset
   906
   - finished by the user
hgs
parents:
diff changeset
   907
 */
hgs
parents:
diff changeset
   908
void WlanWizardPrivate::closeViews()
hgs
parents:
diff changeset
   909
{
39
hgs
parents: 31
diff changeset
   910
    mDialog->hide();
31
hgs
parents:
diff changeset
   911
    mClosed = true;
hgs
parents:
diff changeset
   912
}
hgs
parents:
diff changeset
   913
hgs
parents:
diff changeset
   914
/*!
hgs
parents:
diff changeset
   915
   This method takes care of the title of wizard and toolbutton. Correct items
hgs
parents:
diff changeset
   916
   are selected based on the \a pageId and the amount of objects in the stacked
hgs
parents:
diff changeset
   917
   widget.
hgs
parents:
diff changeset
   918
   
hgs
parents:
diff changeset
   919
   @param [in] pageId Wizard Page Id
hgs
parents:
diff changeset
   920
 */
hgs
parents:
diff changeset
   921
void WlanWizardPrivate::updateFrame(int pageId)
hgs
parents:
diff changeset
   922
{
hgs
parents:
diff changeset
   923
    int currentIndex = mStackedWidget->currentIndex();
hgs
parents:
diff changeset
   924
hgs
parents:
diff changeset
   925
    OstTraceExt3( TRACE_FLOW, WLANWIZARDPRIVATE_UPDATEFRAME, 
hgs
parents:
diff changeset
   926
        "WlanWizardPrivate::updateFrame;this=%x;pageId=%{PageIds};currentIndex=%d",
hgs
parents:
diff changeset
   927
        (unsigned)this, pageId, (uint)(currentIndex) );
hgs
parents:
diff changeset
   928
    
hgs
parents:
diff changeset
   929
    // For last page (summary) show Finish instead of Next button
hgs
parents:
diff changeset
   930
    if (pageId == WlanWizardPageInternal::PageSummary) {
hgs
parents:
diff changeset
   931
        mTitle->setPlainText(hbTrId("txt_occ_title_wlan_setup_wizard_summary"));
hgs
parents:
diff changeset
   932
        mActionFinish->setVisible(true);
hgs
parents:
diff changeset
   933
        mActionNext->setVisible(false);
hgs
parents:
diff changeset
   934
        mActionPrevious->setVisible(false);
hgs
parents:
diff changeset
   935
    } else {
hgs
parents:
diff changeset
   936
        // Index starts from zero, wizard page numbering starts from one.
hgs
parents:
diff changeset
   937
        mTitle->setPlainText(
hgs
parents:
diff changeset
   938
            hbTrId("txt_occ_title_wlan_setup_wizard_step_l1").arg(
hgs
parents:
diff changeset
   939
                currentIndex + 1));
hgs
parents:
diff changeset
   940
        mActionFinish->setVisible(false);
hgs
parents:
diff changeset
   941
        mActionNext->setVisible(true);
hgs
parents:
diff changeset
   942
hgs
parents:
diff changeset
   943
        // If first page is shown then Previous button is disabled
hgs
parents:
diff changeset
   944
        if (currentIndex < 1) {
hgs
parents:
diff changeset
   945
            mActionPrevious->setVisible(false);
hgs
parents:
diff changeset
   946
        } else {
hgs
parents:
diff changeset
   947
            mActionPrevious->setVisible(true);
hgs
parents:
diff changeset
   948
            if (pageId == WlanWizardPage::PageProcessSettings) {
hgs
parents:
diff changeset
   949
                mActionPrevious->setEnabled(false);
hgs
parents:
diff changeset
   950
            } else {
hgs
parents:
diff changeset
   951
                mActionPrevious->setEnabled(true);
hgs
parents:
diff changeset
   952
            }
hgs
parents:
diff changeset
   953
        }
hgs
parents:
diff changeset
   954
    }
hgs
parents:
diff changeset
   955
}
hgs
parents:
diff changeset
   956
hgs
parents:
diff changeset
   957
/*!
hgs
parents:
diff changeset
   958
   Loads widgets and objects from the docml file. 
hgs
parents:
diff changeset
   959
 */
hgs
parents:
diff changeset
   960
void WlanWizardPrivate::loadDocml()
hgs
parents:
diff changeset
   961
{
hgs
parents:
diff changeset
   962
    bool ok = true;
hgs
parents:
diff changeset
   963
    
hgs
parents:
diff changeset
   964
    mDocLoader->load(":/docml/occ_wlan_wizard_main.docml", &ok);
hgs
parents:
diff changeset
   965
    Q_ASSERT(ok);
hgs
parents:
diff changeset
   966
hgs
parents:
diff changeset
   967
    mDialog.reset( qobject_cast<HbDialog*> (mDocLoader->findWidget("dialog")) );
hgs
parents:
diff changeset
   968
    Q_ASSERT(mDialog != NULL);
hgs
parents:
diff changeset
   969
hgs
parents:
diff changeset
   970
    mTitle = qobject_cast<HbLabel*> (mDocLoader->findWidget("title"));
hgs
parents:
diff changeset
   971
    Q_ASSERT(mTitle != NULL);
hgs
parents:
diff changeset
   972
hgs
parents:
diff changeset
   973
    mStackedWidget = 
hgs
parents:
diff changeset
   974
        qobject_cast<HbStackedWidget*> (mDocLoader->findWidget("stackedWidget"));
hgs
parents:
diff changeset
   975
    Q_ASSERT(mStackedWidget != NULL);
hgs
parents:
diff changeset
   976
hgs
parents:
diff changeset
   977
    mActionNext = qobject_cast<HbAction*> (mDocLoader->findObject("actionNext"));
hgs
parents:
diff changeset
   978
    Q_ASSERT(mActionNext != NULL);
hgs
parents:
diff changeset
   979
hgs
parents:
diff changeset
   980
    mActionPrevious = 
hgs
parents:
diff changeset
   981
        qobject_cast<HbAction*> (mDocLoader->findObject("actionPrevious"));
hgs
parents:
diff changeset
   982
    Q_ASSERT(mActionPrevious != NULL);
hgs
parents:
diff changeset
   983
hgs
parents:
diff changeset
   984
    mActionFinish = 
hgs
parents:
diff changeset
   985
        qobject_cast<HbAction*> (mDocLoader->findObject("actionFinish"));
hgs
parents:
diff changeset
   986
    Q_ASSERT(mActionFinish != NULL);
hgs
parents:
diff changeset
   987
hgs
parents:
diff changeset
   988
    mActionCancel = 
hgs
parents:
diff changeset
   989
        qobject_cast<HbAction*> (mDocLoader->findObject("actionCancel"));
hgs
parents:
diff changeset
   990
    Q_ASSERT(mActionCancel != NULL);
hgs
parents:
diff changeset
   991
    
hgs
parents:
diff changeset
   992
    // Actions are added from left to right to the toolbar of dialog
hgs
parents:
diff changeset
   993
    mDialog->addAction(mActionPrevious);
hgs
parents:
diff changeset
   994
    mDialog->addAction(mActionCancel);
hgs
parents:
diff changeset
   995
    mDialog->addAction(mActionNext);
hgs
parents:
diff changeset
   996
    mDialog->addAction(mActionFinish);
hgs
parents:
diff changeset
   997
    
hgs
parents:
diff changeset
   998
    // TODO: workaround to prevent action to close the dialog
hgs
parents:
diff changeset
   999
    disconnect(mActionPrevious, SIGNAL(triggered()), mDialog.data(), SLOT(close()));
hgs
parents:
diff changeset
  1000
    disconnect(mActionCancel, SIGNAL(triggered()), mDialog.data(), SLOT(close()));
hgs
parents:
diff changeset
  1001
    disconnect(mActionNext, SIGNAL(triggered()), mDialog.data(), SLOT(close()));
hgs
parents:
diff changeset
  1002
    disconnect(mActionFinish, SIGNAL(triggered()), mDialog.data(), SLOT(close()));
hgs
parents:
diff changeset
  1003
hgs
parents:
diff changeset
  1004
    ok = true;
hgs
parents:
diff changeset
  1005
    ok = connect(mPageTimer, SIGNAL(timeout()), this, SLOT(onTimeOut()));
hgs
parents:
diff changeset
  1006
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1007
    
hgs
parents:
diff changeset
  1008
    ok = connect(
hgs
parents:
diff changeset
  1009
        mActionNext, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1010
        this, SLOT(nextTriggered()));
hgs
parents:
diff changeset
  1011
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1012
    
hgs
parents:
diff changeset
  1013
    ok = connect(
hgs
parents:
diff changeset
  1014
        mActionPrevious, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1015
        this, SLOT(previousTriggered()));
hgs
parents:
diff changeset
  1016
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1017
    
hgs
parents:
diff changeset
  1018
    ok = connect(
hgs
parents:
diff changeset
  1019
        mActionFinish, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1020
        this, SLOT(finishTriggered()));
hgs
parents:
diff changeset
  1021
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1022
    
hgs
parents:
diff changeset
  1023
    ok = connect(
hgs
parents:
diff changeset
  1024
        mActionCancel, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1025
        this, SLOT(cancelTriggered()));
hgs
parents:
diff changeset
  1026
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1027
hgs
parents:
diff changeset
  1028
    // TODO: workaround for full screen dialog, with docml it is possible to
hgs
parents:
diff changeset
  1029
    // define fullscreen dialog, mut resize is not done correctly when orientation
hgs
parents:
diff changeset
  1030
    // is changed. See TSW Error: MTAA-854DK8
hgs
parents:
diff changeset
  1031
    ok = HbStyleLoader::registerFilePath(":/css/custom.css");
hgs
parents:
diff changeset
  1032
    Q_ASSERT(ok);
hgs
parents:
diff changeset
  1033
}
hgs
parents:
diff changeset
  1034
hgs
parents:
diff changeset
  1035
/*!
hgs
parents:
diff changeset
  1036
   Disconnect receiving triggered() signal from any toolbar action.
hgs
parents:
diff changeset
  1037
 */
hgs
parents:
diff changeset
  1038
void WlanWizardPrivate::disconnectActions()
hgs
parents:
diff changeset
  1039
{
hgs
parents:
diff changeset
  1040
    disconnect(
hgs
parents:
diff changeset
  1041
        mActionNext, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1042
        this, SLOT(nextTriggered()));
hgs
parents:
diff changeset
  1043
    
hgs
parents:
diff changeset
  1044
    disconnect(
hgs
parents:
diff changeset
  1045
        mActionPrevious, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1046
        this, SLOT(previousTriggered()));
hgs
parents:
diff changeset
  1047
    
hgs
parents:
diff changeset
  1048
    disconnect(
hgs
parents:
diff changeset
  1049
        mActionFinish, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1050
        this, SLOT(finishTriggered()));
hgs
parents:
diff changeset
  1051
hgs
parents:
diff changeset
  1052
    disconnect(
hgs
parents:
diff changeset
  1053
        mActionCancel, SIGNAL(triggered()), 
hgs
parents:
diff changeset
  1054
        this, SLOT(cancelTriggered()));
hgs
parents:
diff changeset
  1055
}