Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phonesettings/cpphonesettingsplugins/divertplugin/src/cpdivertplugingroup.cpp
branchGCC_SURGE
changeset 51 f39ed5e045e0
parent 30 ebdbd102c78a
parent 46 bc5a64e5bc3c
equal deleted inserted replaced
40:bab96b7ed1a4 51:f39ed5e045e0 
    13  *
 
    13  *
 
    14  * Description:  
    14  * Description:  
    15  *
 
    15  *
 
    16  */
 
    16  */
 
    17 
    17 
    18 #include <QEventLoop>
 
       
    19 #include <hbdataformmodel.h>
 
    18 #include <hbdataformmodel.h>
 
    20 #include <hbdataformmodelitem.h>
 
    19 #include <hbdataformmodelitem.h>
 
    21 #include <hblineedit.h>
 
    20 #include <hblineedit.h>
 
    22 #include <hbinputeditorinterface.h>
 
    21 #include <hbinputeditorinterface.h>
 
    23 #include <hbcombobox.h>
 
    22 #include <hbcombobox.h>
 
    26 #include <psetwrapper.h>
 
    25 #include <psetwrapper.h>
 
    27 #include <hbaction.h>
 
    26 #include <hbaction.h>
 
    28 #include <hblistwidget.h>
 
    27 #include <hblistwidget.h>
 
    29 #include <hblistwidgetitem.h>
 
    28 #include <hblistwidgetitem.h>
 
    30 #include <hblabel.h>
 
    29 #include <hblabel.h>
 
       
    30 #include <hbparameterlengthlimiter.h>
 
    31 #include <cpitemdatahelper.h>
 
    31 #include <cpitemdatahelper.h>
 
    32 #include "cpdivertselectionitem.h"
 
       
    33 #include "cpdivertplugingroup.h"
 
    32 #include "cpdivertplugingroup.h"
 
    34 #include "cpplugincommon.h"
 
    33 #include "cpplugincommon.h"
 
    35 #include "cpphonenotes.h"
 
    34 #include "cpphonenotes.h"
 
    36 #include "cppluginlogging.h"
 
    35 #include "cppluginlogging.h"
 
    37 #include "cpdivertitemdata.h"
 
    36 #include "cpdivertitemdata.h"
 
    38 #include "cpdivertselectioncustomitem.h"
 
       
    39 
    37 
    40 Q_DECLARE_METATYPE(PsCallDivertingCondition)
 
    38 Q_DECLARE_METATYPE(PsCallDivertingCondition)
 
    41 Q_DECLARE_METATYPE(PsServiceGroup)
 
    39 Q_DECLARE_METATYPE(PsServiceGroup)
 
    42 
    40 
    43 // CONSTANTS 
    41 // CONSTANTS 
    44 const QString KVoiceMail("voiceMail");
 
       
    45 const QString KVideoMail("voiceMail");
 
       
    46 const QString KOtherNumber("otherNumber");
 
    42 const QString KOtherNumber("otherNumber");
 
    47 
    43 
    48 /*!
 
    44 /*!
 
    49   CpDivertPluginGroup::CpDivertPluginGroup.
 
    45   CpDivertPluginGroup::CpDivertPluginGroup.
 
    50  */
 
    46  */
 
    61        m_DataItemVideoIfNotAnswered(NULL),
 
    57        m_DataItemVideoIfNotAnswered(NULL),
 
    62        m_DataItemVideoIfOutOfReach(NULL),
 
    58        m_DataItemVideoIfOutOfReach(NULL),
 
    63        m_DataItemVideoIfNotAvailable(NULL),
 
    59        m_DataItemVideoIfNotAvailable(NULL),
 
    64        m_activeNoteId(0),
 
    60        m_activeNoteId(0),
 
    65        m_activeProgressNoteId(0),
 
    61        m_activeProgressNoteId(0),
 
    66        m_divertToVoiceMailBox(false),
 
       
    67        m_helper(helper),
 
    62        m_helper(helper),
 
    68        m_divertTimeout(0)
 
    63        m_activateDivertPhase(NonePhase),
 
       
    64        m_dialog(NULL)
 
    69 {
 
    65 {
 
    70     DPRINT << ": IN";
 
    66     DPRINT << ": IN";
 
    71     
    67     
    72     // Registration needed, because PsCallDivertingCondition and PsServiceGroup
 
    68     // Registration needed, because PsCallDivertingCondition and PsServiceGroup
 
    73     // is used as a custom meta information for barring items.
 
    69     // is used as a custom meta information for barring items.
 
   103     QObject::connect(
 
    99     QObject::connect(
 
   104         m_callDivertingWrapper, 
   100         m_callDivertingWrapper, 
   105         SIGNAL(requestDone()),
 
   101         SIGNAL(requestDone()),
 
   106         this,
 
   102         this,
 
   107         SLOT(divertRequestProcessed()));
 
   103         SLOT(divertRequestProcessed()));
 
   108 
       
   109     // Create custom item prototype
 
       
   110     m_helper.addItemPrototype(new CpDivertSelectionItem());
 
       
   111     
   104     
   112     // Listen form item visibility change
 
   105     // Listen form item visibility change
 
   113     m_helper.connectToForm(
 
   106     m_helper.connectToForm(
 
   114             SIGNAL(itemShown(QModelIndex)), this, SLOT(itemShown(QModelIndex)));
 
   107             SIGNAL(itemShown(QModelIndex)), this, SLOT(itemShown(QModelIndex)));
 
   115     
   108     
   116     // Create grouped setting items
 
   109     // Create grouped setting items
 
   117     createVoiceCallItems(this);
 
   110     createVoiceCallItems(this);
 
   118     createVideoCallItems(this);
 
   111     createVideoCallItems(this);
 
   119     
   112         
   120     m_eventLoop = new QEventLoop(this); 
       
   121     
       
   122     DPRINT << ": OUT";
 
   113     DPRINT << ": OUT";
 
   123 }
 
   114 }
 
   124 
   115 
   125 /*!
 
   116 /*!
 
   126   CpDivertPluginGroup::~CpDivertPluginGroup.
 
   117   CpDivertPluginGroup::~CpDivertPluginGroup.
 
   142 {
 
   133 {
 
   143     DPRINT << ": IN";
 
   134     DPRINT << ": IN";
 
   144     CpSettingFormItemData *page = new CpSettingFormItemData(
 
   135     CpSettingFormItemData *page = new CpSettingFormItemData(
 
   145                 HbDataFormModelItem::GroupPageItem,
 
   136                 HbDataFormModelItem::GroupPageItem,
 
   146                 hbTrId("txt_phone_setlabel_service_val_voice_divert"));
 
   137                 hbTrId("txt_phone_setlabel_service_val_voice_divert"));
 
       
   138     page->setObjectName("voiceCallSettingsGroupItem");
 
   147     parent->appendChild(page);
 
   139     parent->appendChild(page);
 
   148 
   140 
   149     m_DataItemVoiceAllCalls = createDivertItem(
 
   141     m_DataItemVoiceAllCalls = createDivertItem(
 
   150             DivertConditionUnconditional,
 
   142             DivertConditionUnconditional,
 
   151             ServiceGroupVoice,
 
   143             ServiceGroupVoice,
 
   152             hbTrId("txt_phone_setlabel_all_calls"),
 
   144             hbTrId("txt_phone_setlabel_all_calls"),
 
   153             hbTrId("txt_phone_setlabel_all_calls"), false,
 
   145             hbTrId("txt_phone_setlabel_all_calls"), false,
 
   154             page);
 
   146             page);
 
       
   147     m_DataItemVoiceAllCalls->setObjectName("voiceAllCallsDataItem");
 
   155 
   148 
   156     m_DataItemVoiceIfBusy = createDivertItem(
 
   149     m_DataItemVoiceIfBusy = createDivertItem(
 
   157             DivertConditionBusy,
 
   150             DivertConditionBusy,
 
   158             ServiceGroupVoice,
 
   151             ServiceGroupVoice,
 
   159             hbTrId("txt_phone_setlabel_if_busy"),
 
   152             hbTrId("txt_phone_setlabel_if_busy"),
 
   160             hbTrId("txt_phone_setlabel_if_busy"), false,
 
   153             hbTrId("txt_phone_setlabel_if_busy"), false,
 
   161             page);
 
   154             page);
 
       
   155     m_DataItemVoiceIfBusy->setObjectName("voiceIfBusyDataItem"); 
   162 
   156 
   163     m_DataItemVoiceIfNotAnswered = createDivertItem(
 
   157     m_DataItemVoiceIfNotAnswered = createDivertItem(
 
   164             DivertConditionNoReply,
 
   158             DivertConditionNoReply,
 
   165             ServiceGroupVoice,
 
   159             ServiceGroupVoice,
 
   166             hbTrId("txt_phone_setlabel_if_not_answered"),
 
   160             hbTrId("txt_phone_setlabel_if_not_answered"),
 
   167             hbTrId("txt_phone_setlabel_if_not_answered"), true,
 
   161             hbTrId("txt_phone_setlabel_if_not_answered"), true,
 
   168             page);
 
   162             page);
 
   169     m_DataItemVoiceIfNotAnswered->setContentWidgetData(
 
   163     m_DataItemVoiceIfNotAnswered->setObjectName("voiceIfNotAnsweredDataItem");
 
   170             "timeoutText", hbTrId("txt_phone_setlabel_delay"));
 
   164     
   171 
       
   172     m_DataItemVoiceIfOutOfReach = createDivertItem(
 
   165     m_DataItemVoiceIfOutOfReach = createDivertItem(
 
   173             DivertConditionNotReachable,
 
   166             DivertConditionNotReachable,
 
   174             ServiceGroupVoice,
 
   167             ServiceGroupVoice,
 
   175             hbTrId("txt_phone_setlabel_if_out_of_reach"),
 
   168             hbTrId("txt_phone_setlabel_if_out_of_reach"),
 
   176             hbTrId("txt_phone_setlabel_if_out_of_reach"), false,
 
   169             hbTrId("txt_phone_setlabel_if_out_of_reach"), false,
 
   177             page);
 
   170             page);
 
   178 
   171     m_DataItemVoiceIfOutOfReach->setObjectName("voiceIfOutOfReachDataItem");
 
       
   172     
   179     m_DataItemVoiceIfNotAvailable = createDivertItem(
 
   173     m_DataItemVoiceIfNotAvailable = createDivertItem(
 
   180             DivertConditionAllConditionalCases,
 
   174             DivertConditionAllConditionalCases,
 
   181             ServiceGroupVoice,
 
   175             ServiceGroupVoice,
 
   182             hbTrId("txt_phone_setlabel_if_not_available"),
 
   176             hbTrId("txt_phone_setlabel_if_not_available"),
 
   183             hbTrId("txt_phone_setlabel_if_not_available"), true,
 
   177             hbTrId("txt_phone_setlabel_if_not_available"), true,
 
   184             page);
 
   178             page);
 
       
   179     m_DataItemVoiceIfNotAvailable->setObjectName("voiceIfNotAvailableDataItem");
 
   185 
   180 
   186     DPRINT << ": OUT";
 
   181     DPRINT << ": OUT";
 
   187 }
 
   182 }
 
   188 
   183 
   189 /*!
 
   184 /*!
 
   190  CpDivertPluginGroup::createVideoCallItems
 
   185  CpDivertPluginGroup::createVideoCallItems
 
   191  */
 
   186  */
 
   192 void CpDivertPluginGroup::createVideoCallItems(CpSettingFormItemData *parent)
 
   187 void CpDivertPluginGroup::createVideoCallItems(CpSettingFormItemData *parent)
 
   193 {
 
   188 {
 
   194     DPRINT << ": IN";
 
   189     DPRINT << ": IN";
 
       
   190     
   195     CpSettingFormItemData *page = new CpSettingFormItemData(
 
   191     CpSettingFormItemData *page = new CpSettingFormItemData(
 
   196             HbDataFormModelItem::GroupPageItem,
 
   192             HbDataFormModelItem::GroupPageItem,
 
   197             hbTrId("txt_phone_setlabel_service_val_video_divert"));
 
   193             hbTrId("txt_phone_setlabel_service_val_video_divert"));
 
       
   194     page->setObjectName("videoCallSettingsGroupItem"); 
   198     
   195     
   199     parent->appendChild(page);
 
   196     parent->appendChild(page);
 
   200     
   197     
   201     m_DataItemVideoAllCalls = createDivertItem(
 
   198     m_DataItemVideoAllCalls = createDivertItem(
 
   202             DivertConditionUnconditional,
 
   199             DivertConditionUnconditional,
 
   203             ServiceGroupData,
 
   200             ServiceGroupData,
 
   204             hbTrId("txt_phone_setlabel_all_calls"),
 
   201             hbTrId("txt_phone_setlabel_all_calls"),
 
   205             hbTrId("txt_phone_setlabel_all_calls"), false,
 
   202             hbTrId("txt_phone_setlabel_all_calls"), false,
 
   206             page);
 
   203             page);
 
       
   204     m_DataItemVideoAllCalls->setObjectName("videoAllCallsDataItem");
 
   207 
   205 
   208     m_DataItemVideoIfBusy = createDivertItem(
 
   206     m_DataItemVideoIfBusy = createDivertItem(
 
   209             DivertConditionBusy,
 
   207             DivertConditionBusy,
 
   210             ServiceGroupData,
 
   208             ServiceGroupData,
 
   211             hbTrId("txt_phone_setlabel_if_busy"),
 
   209             hbTrId("txt_phone_setlabel_if_busy"),
 
   212             hbTrId("txt_phone_setlabel_if_busy"), false,
 
   210             hbTrId("txt_phone_setlabel_if_busy"), false,
 
   213             page);
 
   211             page);
 
   214 
   212     m_DataItemVideoIfBusy->setObjectName("videoIfBusyDataItem");
 
       
   213     
   215     m_DataItemVideoIfNotAnswered = createDivertItem(
 
   214     m_DataItemVideoIfNotAnswered = createDivertItem(
 
   216             DivertConditionNoReply,
 
   215             DivertConditionNoReply,
 
   217             ServiceGroupData,
 
   216             ServiceGroupData,
 
   218             hbTrId("txt_phone_setlabel_if_not_answered"),
 
   217             hbTrId("txt_phone_setlabel_if_not_answered"),
 
   219             hbTrId("txt_phone_setlabel_if_not_answered"), true,
 
   218             hbTrId("txt_phone_setlabel_if_not_answered"), true,
 
   220             page);
 
   219             page);
 
   221     m_DataItemVideoIfNotAnswered->setContentWidgetData(
 
   220     m_DataItemVideoIfNotAnswered->setObjectName("videoIfNotAnsweredDataItem");
 
   222             "timeoutText", hbTrId("txt_phone_setlabel_delay"));
 
   221     
   223 
       
   224     m_DataItemVideoIfOutOfReach = createDivertItem(
 
   222     m_DataItemVideoIfOutOfReach = createDivertItem(
 
   225             DivertConditionNotReachable,
 
   223             DivertConditionNotReachable,
 
   226             ServiceGroupData,
 
   224             ServiceGroupData,
 
   227             hbTrId("txt_phone_setlabel_if_out_of_reach"),
 
   225             hbTrId("txt_phone_setlabel_if_out_of_reach"),
 
   228             hbTrId("txt_phone_setlabel_if_out_of_reach"), false,
 
   226             hbTrId("txt_phone_setlabel_if_out_of_reach"), false,
 
   229             page);
 
   227             page);
 
   230 
   228     m_DataItemVideoIfOutOfReach->setObjectName("videoIfOutOfReachDataItem");
 
       
   229     
   231     m_DataItemVideoIfNotAvailable = createDivertItem(
 
   230     m_DataItemVideoIfNotAvailable = createDivertItem(
 
   232             DivertConditionAllConditionalCases,
 
   231             DivertConditionAllConditionalCases,
 
   233             ServiceGroupData,
 
   232             ServiceGroupData,
 
   234             hbTrId("txt_phone_setlabel_if_not_available"),
 
   233             hbTrId("txt_phone_setlabel_if_not_available"),
 
   235             hbTrId("txt_phone_setlabel_if_not_available"), true,
 
   234             hbTrId("txt_phone_setlabel_if_not_available"), true,
 
   236             page);
 
   235             page);
 
       
   236     m_DataItemVideoIfNotAvailable->setObjectName("videoIfNotAvailableDataItem");
 
   237     
   237     
   238     DPRINT << ": OUT";
 
   238     DPRINT << ": OUT";
 
   239 }
 
   239 }
 
   240 
   240 
   241 /*!
 
   241 /*!
 
   248         const QString &queryLabel,
 
   248         const QString &queryLabel,
 
   249         bool needTimeoutInfo,
 
   249         bool needTimeoutInfo,
 
   250         CpSettingFormItemData *parent)
 
   250         CpSettingFormItemData *parent)
 
   251 {
 
   251 {
 
   252     DPRINT << ": IN";
 
   252     DPRINT << ": IN";
 
   253 
   253     
   254     CpDivertItemData *item = new CpDivertItemData(
 
   254     CpDivertItemData *item = new CpDivertItemData(
 
   255         static_cast<HbDataFormModelItem::DataItemType>
 
   255         HbDataFormModelItem::CheckBoxItem,
 
   256             (CpDivertSelectionItem::CpDivertSelectionItemId), 
       
   257             label,
 
   256             label,
 
   258             m_helper,
 
   257             m_helper,
 
   259             parent);
 
   258             parent);
 
       
   259     
   260     QVariant conditionVar;
 
   260     QVariant conditionVar;
 
   261     conditionVar.setValue(condition);
 
   261     conditionVar.setValue(condition);
 
   262     item->setProperty("condition", conditionVar);
 
   262     item->setProperty("condition", conditionVar);
 
   263     QVariant serviceGroupVar;
 
   263     QVariant serviceGroupVar;
 
   264     serviceGroupVar.setValue(serviceGroup);
 
   264     serviceGroupVar.setValue(serviceGroup);
 
   265     item->setProperty("serviceGroup", serviceGroupVar);
 
   265     item->setProperty("serviceGroup", serviceGroupVar);
 
   266     item->setProperty("queryLabel", queryLabel);
 
   266     item->setProperty("queryLabel", queryLabel);
 
   267     item->setProperty("needTimeoutInfo", needTimeoutInfo);
 
   267     item->setProperty("needTimeoutInfo", needTimeoutInfo);
 
       
   268     item->setProperty("divertItem", true);
 
   268     item->setEnabled(false);
 
   269     item->setEnabled(false);
 
   269     
   270     
   270     // Connect signals
 
   271     // Connect signals
 
   271     QObject::connect(
 
   272     QObject::connect(
 
   272         item, SIGNAL(itemClicked(CpDivertItemData&)),
 
   273         item, SIGNAL(itemClicked(CpDivertItemData&)),
 
   273         this, SLOT(changeDivertingStateRequested(CpDivertItemData&)));
 
   274         this, SLOT(changeDivertingStateRequested(CpDivertItemData&)));
 
   274     
   275     
   275     parent->appendChild(item);
 
   276     parent->appendChild(item);
 
       
   277     
   276     DPRINT << ": OUT";
 
   278     DPRINT << ": OUT";
 
   277     return item;
 
   279     return item;
 
   278 }
 
   280 }
 
   279 
   281 
   280 /*!
 
   282 /*!
 
   284 {
 
   286 {
 
   285     DPRINT << ": IN";
 
   287     DPRINT << ": IN";
 
   286     DPRINT << "item:" << item;
 
   288     DPRINT << "item:" << item;
 
   287     
   289     
   288     HbDataFormModelItem* modelItem = 
   290     HbDataFormModelItem* modelItem = 
   289             qobject_cast<const HbDataFormModel*>(item.model())->itemFromIndex(item);
 
   291         qobject_cast<const HbDataFormModel*>(item.model())->itemFromIndex(item);
 
   290     
   292     if (!isDivertSettingsItem(modelItem)) {
 
   291     if (!modelItem->contentWidgetData("number").isValid() &&
 
   293         return;
 
   292         (static_cast<HbDataFormModelItem::DataItemType>
 
   294     }
 
   293             (CpDivertSelectionItem::CpDivertSelectionItemId == modelItem->type()))){
 
   295     
       
   296     bool isInitialStatusQueryDoneForItem = 
       
   297         modelItem->contentWidgetData("text").isValid();
 
       
   298     if (!isInitialStatusQueryDoneForItem) {
 
   294         CpDivertItemData *item = static_cast<CpDivertItemData*>(modelItem); 
   299         CpDivertItemData *item = static_cast<CpDivertItemData*>(modelItem); 
   295         if(qvariant_cast<PsCallDivertingCondition>(item->property("condition")) !=
 
   300         if (qvariant_cast<PsCallDivertingCondition>(item->property("condition")) !=
 
   296                 DivertConditionAllConditionalCases) {
 
   301                 DivertConditionAllConditionalCases) {
 
   297             addToDivertingRequestQueue(CheckDivertStatus, *item);
 
   302             addToDivertingRequestQueue(CheckDivertStatus, *item);
 
   298         }
 
   303         }
 
   299     }
 
   304     }
 
   300 
   305     
   301     DPRINT << ": OUT";
 
   306     DPRINT << ": OUT";
 
   302 }
 
   307 }
 
   303 
   308 
   304 /*!
 
   309 /*!
 
   305   CpDivertPluginGroup::addToDivertingRequestQueue.
 
   310   CpDivertPluginGroup::addToDivertingRequestQueue.
 
   306  */
 
   311  */
 
   307 void CpDivertPluginGroup::addToDivertingRequestQueue(
 
   312 void CpDivertPluginGroup::addToDivertingRequestQueue(
 
   308         DivertRequest request, CpDivertItemData &item)
 
   313         DivertRequest request, CpDivertItemData &item)
 
   309 {
 
   314 {
 
   310     DPRINT << ": IN";
 
   315     DPRINT << ": IN";
 
       
   316     
   311     CpDivertRequestQueueItem i;
 
   317     CpDivertRequestQueueItem i;
 
   312     i.request = request;
 
   318     i.request = request;
 
   313     i.item = &item;
 
   319     i.item = &item;
 
   314     m_divertRequestQueue.enqueue(i);
 
   320     m_divertRequestQueue.enqueue(i);
 
   315 
   321 
   316     if (m_divertRequestQueue.count()==1) {
 
   322     if (m_divertRequestQueue.count() == 1) {
 
   317        // Process if first item was added, process other later
 
   323         // Process if first item was added, process other later
 
   318         try {
 
   324         processDivertingRequestQueue();
 
   319             processDivertingRequestQueue();
 
   325     }
 
   320         } catch(...) {
 
       
   321             DPRINT << "error!!";
 
       
   322         }
 
       
   323     }
 
       
   324 
       
   325 
   326 
   326     DPRINT << ": OUT";
 
   327     DPRINT << ": OUT";
 
   327 }
 
   328 }
 
   328 
   329 
   329 /*!
 
   330 /*!
 
   330   CpDivertPluginGroup::divertRequestProcessed.
 
   331   CpDivertPluginGroup::divertRequestProcessed.
 
   331  */
 
   332  */
 
   332 void CpDivertPluginGroup::divertRequestProcessed()
 
   333 void CpDivertPluginGroup::divertRequestProcessed()
 
   333 {
 
   334 {
 
   334     DPRINT << ": IN";
 
   335     DPRINT << ": IN";
 
       
   336     
   335     // Remove previous request and process next one
 
   337     // Remove previous request and process next one
 
   336     if (!m_divertRequestQueue.isEmpty()) {
 
   338     if (!m_divertRequestQueue.isEmpty()) {
 
   337         m_divertRequestQueue.dequeue();
 
   339         m_divertRequestQueue.dequeue();
 
   338         processDivertingRequestQueue();
 
   340         processDivertingRequestQueue();
 
   339     }
 
   341     }
 
   351  */
 
   353  */
 
   352 void CpDivertPluginGroup::changeItemData(
 
   354 void CpDivertPluginGroup::changeItemData(
 
   353         PsServiceGroup serviceGroup,
 
   355         PsServiceGroup serviceGroup,
 
   354         PsCallDivertingCondition condition,
 
   356         PsCallDivertingCondition condition,
 
   355         PsCallDivertingStatus status,
 
   357         PsCallDivertingStatus status,
 
   356         const QString& number, int timeout)
 
   358         const QString& aNumber, int aTimeout)
 
   357 {
 
   359 {
 
   358     DPRINT << ": IN";
 
   360     DPRINT << ": IN";
 
   359     
   361     
   360     CpDivertSelectionCustomitem::State itemState = 
   362     Qt::CheckState itemState = Qt::Unchecked;
 
   361         CpDivertSelectionCustomitem::Disabled;
 
       
   362     if (status == DivertingStatusActive) {
 
   363     if (status == DivertingStatusActive) {
 
   363         itemState = CpDivertSelectionCustomitem::Enabled;
 
   364         itemState = Qt::Checked;
 
   364     } else if (status == DivertingStatusInactive) {
 
   365     } else if (status == DivertingStatusInactive) {
 
   365         itemState = CpDivertSelectionCustomitem::Deactivated;
 
   366         itemState = Qt::PartiallyChecked;
 
   366     } else {
 
   367     } else {
 
   367         itemState = CpDivertSelectionCustomitem::Disabled;
 
   368         itemState = Qt::Unchecked;
 
   368     }
 
   369     }
 
       
   370 
       
   371     QString number = aNumber;
 
       
   372     int timeout = aTimeout;
 
       
   373     if (Qt::PartiallyChecked == itemState) {
 
       
   374         number = QString("");
 
       
   375         timeout = 0;
 
       
   376     }
 
       
   377     
       
   378     QVariant numberValue;
 
       
   379     numberValue.setValue(number);
 
   369     
   380     
   370     switch (condition) {
 
   381     switch (condition) {
 
   371     case DivertConditionAllConditionalCases:
 
   382     case DivertConditionAllConditionalCases:
 
   372         DPRINT << ": DivertConditionAllConditionalCases";
 
   383         DPRINT << ": DivertConditionAllConditionalCases";
 
   373         
   384         
   379     case DivertConditionUnconditional:
 
   390     case DivertConditionUnconditional:
 
   380     case DivertConditionBusy:
 
   391     case DivertConditionBusy:
 
   381     case DivertConditionNoReply:
 
   392     case DivertConditionNoReply:
 
   382     case DivertConditionNotReachable:
 
   393     case DivertConditionNotReachable:
 
   383         if (serviceGroup & ServiceGroupVoice) {
 
   394         if (serviceGroup & ServiceGroupVoice) {
 
   384             item(ServiceGroupVoice, condition)->setContentWidgetData("number", number);
 
   395             CpSettingFormItemData* itemData = item(ServiceGroupVoice, condition); 
   385             item(ServiceGroupVoice, condition)->setContentWidgetData("timeout", timeout);
 
   396             itemData->setContentWidgetData("text", numberValue);
 
   386             item(ServiceGroupVoice, condition)->setContentWidgetData("state", itemState);
 
   397             if (DivertConditionNoReply == condition) {
 
   387             item(ServiceGroupVoice, condition)->setEnabled(true);
 
   398                 if (timeout > 0) {
 
       
   399                     itemData->setDescription(
 
       
   400                             hbTrId("txt_phone_setlabel_divert_delay_ln_seconds", timeout));
 
       
   401                 } else {
 
       
   402                     itemData->setDescription("");
 
       
   403                 }
 
       
   404             }
 
       
   405             itemData->setContentWidgetData("checkState", itemState);
 
       
   406             itemData->setEnabled(true);
 
   388         }
 
   407         }
 
   389         
   408         
   390         if (serviceGroup & ServiceGroupData) {
 
   409         if (serviceGroup & ServiceGroupData) {
 
   391             item(ServiceGroupData, condition)->setContentWidgetData("number", number);
 
   410             CpSettingFormItemData* itemData = item(ServiceGroupData, condition);
 
   392             item(ServiceGroupData, condition)->setContentWidgetData("timeout", timeout);
 
   411             itemData->setContentWidgetData("text", numberValue);
 
   393             item(ServiceGroupData, condition)->setContentWidgetData("state", itemState);
 
   412             if (DivertConditionNoReply == condition) {
 
   394             item(ServiceGroupData, condition)->setEnabled(true);
 
   413                 if (timeout > 0) {
 
   395         }
 
   414                     itemData->setDescription(
 
       
   415                             hbTrId("txt_phone_setlabel_divert_delay_ln_seconds", timeout));
 
       
   416                 } else {
 
       
   417                     itemData->setDescription("");
 
       
   418                 }
 
       
   419             }
 
       
   420             itemData->setContentWidgetData("checkState", itemState);
 
       
   421             itemData->setEnabled(true);
 
       
   422         }
 
       
   423         
   396         break;
 
   424         break;
 
   397     case DivertConditionAllCalls:
 
   425     case DivertConditionAllCalls:
 
   398     case DivertConditionUnknown:
 
   426     case DivertConditionUnknown:
 
   399     default:
 
   427     default:
 
   400         break;
 
   428         break;
 
   401     }
 
   429     }
 
       
   430     
       
   431     DPRINT << ": OUT";
 
   402 }
 
   432 }
 
   403 
   433 
   404 /*!
 
   434 /*!
 
   405   CpDivertPluginGroup::revertItemData.
 
   435   CpDivertPluginGroup::revertItemData.
 
   406  */
 
   436  */
 
   407 void CpDivertPluginGroup::revertItemData(
 
   437 void CpDivertPluginGroup::revertItemData(
 
   408         PsServiceGroup serviceGroup, PsCallDivertingCondition condition)
 
   438         PsServiceGroup serviceGroup, PsCallDivertingCondition condition)
 
   409 {
 
   439 {
 
   410     DPRINT << ": IN";
 
   440     DPRINT << ": IN";
 
       
   441     
   411     if (serviceGroup & ServiceGroupVoice) {
 
   442     if (serviceGroup & ServiceGroupVoice) {
 
   412         item(ServiceGroupVoice, condition)->setContentWidgetData("state",
 
   443         CpSettingFormItemData* itemData = item(ServiceGroupVoice, condition);
 
   413             item(ServiceGroupVoice, condition)->contentWidgetData("state"));
 
   444         int checkState = itemData->contentWidgetData("checkState").toInt();
 
       
   445         int revertedCheckState = 
       
   446             Qt::Checked == checkState ? Qt::Unchecked : Qt::Checked;
 
       
   447         itemData->setContentWidgetData("checkState", revertedCheckState);
 
   414     }
 
   448     }
 
   415     
   449     
   416     if (serviceGroup & ServiceGroupData) {
 
   450     if (serviceGroup & ServiceGroupData) {
 
   417         item(ServiceGroupData, condition)->setContentWidgetData("state",
 
   451         CpSettingFormItemData* itemData = item(ServiceGroupData, condition);
 
   418             item(ServiceGroupData, condition)->contentWidgetData("state"));
 
   452         int checkState = itemData->contentWidgetData("checkState").toInt();
 
   419     }
 
   453         int revertedCheckState = 
   420 
   454             Qt::Checked == checkState ? Qt::Unchecked : Qt::Checked;
 
       
   455         itemData->setContentWidgetData("checkState", revertedCheckState);
 
       
   456     }
 
       
   457     
   421     DPRINT << ": OUT";
 
   458     DPRINT << ": OUT";
 
   422 }
 
   459 }
 
   423 
   460 
   424 /*!
 
   461 /*!
 
   425   CpDivertPluginGroup::item.
 
   462   CpDivertPluginGroup::item.
 
   426  */
 
   463  */
 
   427 CpSettingFormItemData* CpDivertPluginGroup::item(
 
   464 CpSettingFormItemData* CpDivertPluginGroup::item(
 
   428         PsService service, PsCallDivertingCondition condition)
 
   465         PsService service, PsCallDivertingCondition condition)
 
   429 {
 
   466 {
 
       
   467     DPRINT << ": IN";
 
       
   468     
   430     CpSettingFormItemData *ret = 0;
 
   469     CpSettingFormItemData *ret = 0;
 
   431     switch (condition) {
 
   470     switch (condition) {
 
   432         case DivertConditionUnconditional:
 
   471         case DivertConditionUnconditional:
 
   433             if (service == ServiceGroupVoice) {
 
   472             if (service == ServiceGroupVoice) {
 
   434                 ret = m_DataItemVoiceAllCalls;
 
   473                 ret = m_DataItemVoiceAllCalls;
 
   468         case DivertConditionUnknown:
 
   507         case DivertConditionUnknown:
 
   469         default:
 
   508         default:
 
   470             break;
 
   509             break;
 
   471     }
 
   510     }
 
   472     Q_CHECK_PTR(ret);
 
   511     Q_CHECK_PTR(ret);
 
       
   512     
       
   513     DPRINT << ": OUT";
 
   473     return ret;
 
   514     return ret;
 
   474 }
 
   515 }
 
   475 
   516 
   476 /*!
 
   517 /*!
 
   477   CpDivertPluginGroup::processDivertingRequestQueue.
 
   518   CpDivertPluginGroup::processDivertingRequestQueue.
 
   483         DPRINT << "queue empty : OUT";
 
   524         DPRINT << "queue empty : OUT";
 
   484         return;
 
   525         return;
 
   485     }
 
   526     }
 
   486     CpDivertRequestQueueItem request = m_divertRequestQueue.head();
 
   527     CpDivertRequestQueueItem request = m_divertRequestQueue.head();
 
   487     // Command param
 
   528     // Command param
 
   488     PSCallDivertingCommand divertCommand;
 
   529     m_divertCommand.iServiceGroup = qvariant_cast<PsServiceGroup>(
 
   489     divertCommand.iServiceGroup = qvariant_cast<PsServiceGroup>(
 
       
   490             request.item->property("serviceGroup"));
 
   530             request.item->property("serviceGroup"));
 
   491     divertCommand.iCondition = qvariant_cast<PsCallDivertingCondition>(
 
   531     m_divertCommand.iCondition = qvariant_cast<PsCallDivertingCondition>(
 
   492             request.item->property("condition"));
 
   532             request.item->property("condition"));
 
   493     divertCommand.iStatus = DivertingStatusUnknown;
 
   533     m_divertCommand.iStatus = DivertingStatusUnknown;
 
   494     divertCommand.iNumber = "";
 
   534     m_divertCommand.iNumber = "";
 
   495     divertCommand.iNoReplyTimer = 0;
 
   535     m_divertCommand.iNoReplyTimer = 0;
 
   496 
   536 
   497     switch (request.request) {
 
   537     switch (request.request) {
 
   498         case ActivateDivert: {
 
   538         case ActivateDivert: {
 
   499             DPRINT << "activate";
 
   539             DPRINT << "activate";
 
   500             divertCommand.iSetting = RegisterDiverting;
 
   540             m_divertCommand.iSetting = RegisterDiverting;
 
   501             if (popUpVoiceNumberListQuery(
 
   541             m_activateDivertPhase = PopUpVoiceNumberListQueryPhase;
 
   502                     request.item->property("queryLabel").toString(),
 
   542             popUpVoiceNumberListQuery(
 
   503                     divertCommand.iNumber,
 
   543                 request.item->property("queryLabel").toString(),
 
   504                     divertCommand.iServiceGroup)) {
 
   544                         m_divertCommand.iServiceGroup);
 
   505                 if (request.item->property("needTimeoutInfo").toBool()) {
 
       
   506                     if (popUpTimerQuery(divertCommand.iNoReplyTimer)) {
 
       
   507                         setCallDiverting(divertCommand);
 
       
   508                     } else {
 
       
   509                         // Query was cancelled
 
       
   510                         revertItemData(
 
       
   511                                 divertCommand.iServiceGroup, 
       
   512                                 divertCommand.iCondition);
 
       
   513                         m_divertRequestQueue.clear();
 
       
   514                     }
 
       
   515                 } else {
 
       
   516                     setCallDiverting(divertCommand);
 
       
   517                 }
 
       
   518             } else {
 
       
   519                 // Query was cancelled
 
       
   520                 revertItemData(
 
       
   521                         divertCommand.iServiceGroup, 
       
   522                         divertCommand.iCondition);
 
       
   523                 m_divertRequestQueue.clear();
 
       
   524             }
 
       
   525         }
 
   545         }
 
   526             break;
 
   546             break;
 
   527         case DeactivateDivert: {
 
   547         case DeactivateDivert: {
 
   528             DPRINT << "deactivate";
 
   548             DPRINT << "deactivate";
 
   529             divertCommand.iSetting = EraseDiverting;
 
   549             m_divertCommand.iSetting = EraseDiverting;
 
   530             setCallDiverting(divertCommand);
 
   550             setCallDiverting(m_divertCommand);
 
   531         }
 
   551         }
 
   532             break;
 
   552             break;
 
   533         case CheckDivertStatus: {
 
   553         case CheckDivertStatus: {
 
   534             DPRINT << "check status";
 
   554             DPRINT << "check status";
 
   535             m_callDivertingWrapper->getCallDivertingStatus(
 
   555             m_callDivertingWrapper->getCallDivertingStatus(
 
   536                 divertCommand.iServiceGroup,
 
   556                 m_divertCommand.iServiceGroup,
 
   537                 divertCommand.iCondition,
 
   557                 m_divertCommand.iCondition,
 
   538                 bscParam(divertCommand.iServiceGroup) );
 
   558                 bscParam(m_divertCommand.iServiceGroup) );
 
   539             
   559             
   540             if (!CpPhoneNotes::instance()->noteShowing()) {
 
   560             if (!CpPhoneNotes::instance()->noteShowing()) {
 
   541                 CpPhoneNotes::instance()->showGlobalProgressNote(
 
   561                 CpPhoneNotes::instance()->showGlobalProgressNote(
 
   542                         m_activeProgressNoteId, hbTrId("txt_phone_info_requesting"));
 
   562                         m_activeProgressNoteId, 
       
   563                         hbTrId("txt_common_info_requesting"));
 
   543             }
 
   564             }
 
   544         }
 
   565         }
 
   545             break;
 
   566             break;
 
   546         default:
 
   567         default:
 
   547             DPRINT << "Error: unknown enum value";
 
   568             DPRINT << "Error: unknown enum value";
 
   557 void CpDivertPluginGroup::changeDivertingStateRequested(
 
   578 void CpDivertPluginGroup::changeDivertingStateRequested(
 
   558         CpDivertItemData &item)
 
   579         CpDivertItemData &item)
 
   559 {
 
   580 {
 
   560     DPRINT << ": IN";
 
   581     DPRINT << ": IN";
 
   561     
   582     
   562     DivertRequest event=ActivateDivert;
 
   583     DivertRequest event = ActivateDivert;
 
   563     if (CpDivertSelectionCustomitem::Enabled == 
   584     if (Qt::Checked == item.contentWidgetData("checkState").toInt()) {
 
   564             item.contentWidgetData("state").toInt()) {
 
   585         event = ActivateDivert;
 
       
   586     } else {
 
   565         event = DeactivateDivert;
 
   587         event = DeactivateDivert;
 
   566     } else {
 
       
   567         event = ActivateDivert;
 
       
   568     }
 
   588     }
 
   569     
   589     
   570     addToDivertingRequestQueue(event, item);
 
   590     addToDivertingRequestQueue(event, item);
 
   571     DPRINT << ": OUT";
 
   591     DPRINT << ": OUT";
 
   572 }
 
   592 }
 
   596     
   616     
   597     updateDependentDivertOptions(
 
   617     updateDependentDivertOptions(
 
   598             (DivertConditionUnconditional == aSetting.iCondition) &&
 
   618             (DivertConditionUnconditional == aSetting.iCondition) &&
 
   599             (DivertingStatusActive != aSetting.iStatus) );
 
   619             (DivertingStatusActive != aSetting.iStatus) );
 
   600     
   620     
   601     switch(aSetting.iStatus) {
 
   621     switch (aSetting.iStatus) {
 
   602         case DivertingStatusActive:
 
   622         case DivertingStatusActive: {
 
   603             if (aPlural) {
 
   623             if (aPlural) {
 
   604                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
   624                 CpPhoneNotes::instance()->showNotificationDialog(
 
   605                     hbTrId("txt_phone_info_diverts_activated"), 
   625                     hbTrId("txt_phone_info_diverts_activated"));
 
   606                     HbMessageBox::MessageTypeInformation);
 
       
   607             } else {
 
   626             } else {
 
   608                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
   627                 CpPhoneNotes::instance()->showNotificationDialog(
 
   609                     hbTrId("txt_phone_info_divert_activated"), 
   628                     hbTrId("txt_phone_info_divert_activated"));
 
   610                     HbMessageBox::MessageTypeInformation);
 
   629             }
 
   611             }
 
   630             QString voiceMailBoxNumber;
 
   612             if (!m_divertToVoiceMailBox) {
 
   631             QString videoMailBoxNumber;
 
       
   632             m_callDivertingWrapper->getVoiceMailBoxNumber(voiceMailBoxNumber, ServiceGroupVoice);
 
       
   633             m_callDivertingWrapper->getVoiceMailBoxNumber(videoMailBoxNumber, ServiceGroupData);
 
       
   634             if ((aSetting.iNumber != voiceMailBoxNumber) && (aSetting.iNumber != videoMailBoxNumber)) {
 
   613                 // Number, except vmbx number, will be added to defaultnumber list
 
   635                 // Number, except vmbx number, will be added to defaultnumber list
 
   614                 m_callDivertingWrapper->setNewDefaultNumber(aSetting.iNumber);
 
   636                 m_callDivertingWrapper->setNewDefaultNumber(aSetting.iNumber);
 
   615             }
 
   637             }
 
   616             // Diverting calls does not affect Internet calls
 
   638         }
 
   617             if (Tools::voipSupported() &&
 
       
   618                     (aSetting.iServiceGroup & ServiceGroupVoice)) {
 
       
   619                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
       
   620                     hbTrId("Diverting calls does not affect Internet calls"), 
       
   621                     HbMessageBox::MessageTypeInformation);
 
       
   622             }
 
       
   623             break;
 
   639             break;
 
   624         case DivertingStatusNotRegistered:  
   640         case DivertingStatusNotRegistered:  
   625         case DivertingStatusInactive:
 
   641         case DivertingStatusInactive:
 
   626             if (aPlural) {
 
   642             if (aPlural) {
 
   627                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
   643                 CpPhoneNotes::instance()->showNotificationDialog(
 
   628                     hbTrId("txt_phone_info_diverts_deactivated"), 
   644                     hbTrId("txt_phone_info_diverts_deactivated"));
 
   629                     HbMessageBox::MessageTypeInformation);
 
       
   630             } else {
 
   645             } else {
 
   631                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
   646                 CpPhoneNotes::instance()->showNotificationDialog(
 
   632                     hbTrId("txt_phone_info_divert_deactivated"), 
   647                     hbTrId("txt_phone_info_divert_deactivated"));
 
   633                     HbMessageBox::MessageTypeInformation);
 
       
   634             }
 
   648             }
 
   635             break;
 
   649             break;
 
   636         case DivertingStatusNotProvisioned:
 
   650         case DivertingStatusNotProvisioned:
 
   637         case DivertingStatusUnknown:
 
   651         case DivertingStatusUnknown:
 
   638         default:
 
   652         default:
 
   639             CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,
 
   653             CpPhoneNotes::instance()->showNotificationDialog(
 
   640                 hbTrId("txt_phone_info_request_not_completed"), 
   654                 hbTrId("txt_phone_info_request_not_completed"));
 
   641                 HbMessageBox::MessageTypeInformation);
 
   655             break; 
   642     }
 
   656     }
 
   643     
   657     
   644     DPRINT << ": OUT";
 
   658     DPRINT << ": OUT";
 
   645 }
 
   659 }
 
   646    
   660    
   653 {
 
   667 {
 
   654     DPRINT << ": IN";
 
   668     DPRINT << ": IN";
 
   655     DPRINT << "divertList.Size():" << divertList.size();
 
   669     DPRINT << "divertList.Size():" << divertList.size();
 
   656     DPRINT << "plural:" << plural;
 
   670     DPRINT << "plural:" << plural;
 
   657 
   671 
   658     foreach(PSCallDivertingStatus* status, divertList) {
 
   672     foreach (PSCallDivertingStatus* status, divertList) {
 
   659         DPRINT << status->iCondition;
 
   673         DPRINT << status->iCondition;
 
   660         DPRINT << status->iNumber;
 
   674         DPRINT << status->iNumber;
 
   661         DPRINT << status->iServiceGroup;
 
   675         DPRINT << status->iServiceGroup;
 
   662         DPRINT << status->iStatus;
 
   676         DPRINT << status->iStatus;
 
   663         DPRINT << status->iTimeout;
 
   677         DPRINT << status->iTimeout;
 
   686             qvariant_cast<PsServiceGroup>(
 
   700             qvariant_cast<PsServiceGroup>(
 
   687                     m_divertRequestQueue.head().item->property("serviceGroup")),
 
   701                     m_divertRequestQueue.head().item->property("serviceGroup")),
 
   688             qvariant_cast<PsCallDivertingCondition>(
 
   702             qvariant_cast<PsCallDivertingCondition>(
 
   689                     m_divertRequestQueue.head().item->property("condition")));
 
   703                     m_divertRequestQueue.head().item->property("condition")));
 
   690     }
 
   704     }
 
   691     
   705         
   692     // Clear queue
 
   706     // Clear queue
 
   693     m_divertRequestQueue.clear();
 
   707     m_divertRequestQueue.clear();
 
   694     
   708         
   695     // Cancel previous note
 
   709     // Cancel previous note
 
   696     CpPhoneNotes::instance()->cancelNote(m_activeNoteId);
 
   710     CpPhoneNotes::instance()->cancelNote(m_activeNoteId);
 
   697     
   711         
   698     // Show error note
 
   712     // Show error note
 
   699     CpPhoneNotes::instance()->showGlobalErrorNote(m_activeNoteId, aReason);
 
   713     CpPhoneNotes::instance()->showGlobalErrorNote(m_activeNoteId, aReason);
 
   700     
   714     
   701     DPRINT << ": OUT";
 
   715     DPRINT << ": OUT";
 
   702 }
 
   716 }
 
   703 
   717 
   704 /*!
 
   718 /*!
 
   705   CpDivertPluginGroup::popUpVoiceNumberListQuery.
 
   719   CpDivertPluginGroup::popUpVoiceNumberListQuery.
 
   706  */
 
   720  */
 
   707 bool CpDivertPluginGroup::popUpVoiceNumberListQuery(
 
   721 void CpDivertPluginGroup::popUpVoiceNumberListQuery(
 
   708         const QString& heading, QString& result, PsServiceGroup serviceGroup)
 
   722         const QString& heading, PsServiceGroup serviceGroup)
 
   709 {
 
   723 {
 
   710     DPRINT << ": IN";
 
   724     DPRINT << ": IN";
 
   711     
   725     if (m_dialog) {
 
   712     bool requestOK(false);
 
   726         m_dialog->deleteLater();
 
   713 
   727         m_dialog = NULL;
 
   714     if (!m_eventLoop->isRunning()){
 
   728     }
 
   715         m_divertNumber = ""; 
   729 
   716         m_divertToVoiceMailBox = false;
 
   730     m_divertCommand.iNumber.clear();
 
   717         QStringList defNumbers;
 
   731     QStringList defNumbers;
 
   718         HbDialog *dialog = createDialog(heading);
 
   732     QScopedPointer<HbDialog> dialog(createDialog(heading));
 
   719         m_voiceNumberList = new HbListWidget(dialog);
 
   733     HbListWidget *list = new HbListWidget(dialog.data());
 
       
   734     
       
   735     QString vmbxNumber;
 
       
   736     int vmbxErr = 0;
 
       
   737     if (serviceGroup == ServiceGroupVoice) {
 
       
   738         vmbxErr = m_callDivertingWrapper->getVoiceMailBoxNumber(
 
       
   739                 vmbxNumber, ServiceGroupVoice);
 
       
   740         
       
   741     } else if(serviceGroup == ServiceGroupData) {
 
       
   742         vmbxErr = m_callDivertingWrapper->getVoiceMailBoxNumber(
 
       
   743                 vmbxNumber, ServiceGroupData);
 
       
   744         
       
   745     } else {
 
       
   746         vmbxErr = -1;
 
       
   747         // Skip
 
       
   748     }
 
       
   749     
       
   750     if (!vmbxErr) {
 
   720         if (serviceGroup == ServiceGroupVoice) {
 
   751         if (serviceGroup == ServiceGroupVoice) {
 
   721             addItemToListWidget(
 
   752             addItemToListWidget(
 
   722                     m_voiceNumberList, hbTrId("txt_phone_setlabel_voice_mbx"), KVoiceMail );
 
   753                 list, 
   723         } else if(serviceGroup == ServiceGroupData) {
 
   754                 hbTrId("txt_phone_setlabel_voice_mbx"), 
   724             // TODO: Implement video voicemail
 
   755                 vmbxNumber );
 
   725         }
 
   756                 
   726     
   757         } else {
 
   727         // Add "old" divert number to list
 
   758             addItemToListWidget(
 
   728         m_callDivertingWrapper->getDefaultNumbers(defNumbers);
 
   759                 list, 
   729         int count(defNumbers.count());
 
   760                 hbTrId("txt_phone_setlabel_video_mbx"), 
   730         for (int i = 0; i < count; i++) {
 
   761                 vmbxNumber );
 
   731             addItemToListWidget(m_voiceNumberList, defNumbers[i], defNumbers[i]);
 
   762         }
 
   732         }
 
   763     }
 
   733         addItemToListWidget(m_voiceNumberList, hbTrId("txt_phone_list_enter_number_manually"), KOtherNumber );
 
   764 
   734         dialog->setContentWidget(m_voiceNumberList);
 
   765     // Add "old" divert number to list
 
   735         
   766     m_callDivertingWrapper->getDefaultNumbers(defNumbers);
 
   736         // Connect list item activation signal to close the popup
 
   767     int count(defNumbers.count());
 
   737         QObject::connect(m_voiceNumberList, 
   768     for (int i = 0; i < count; i++) {
 
   738                 SIGNAL(activated(HbListWidgetItem*)), 
   769         addItemToListWidget(list, defNumbers[i], defNumbers[i]);
 
   739                 dialog, 
   770     }
 
   740                 SLOT(close()), 
   771     addItemToListWidget(
 
   741                 Qt::UniqueConnection);
 
   772             list, 
   742         
   773             hbTrId("txt_phone_list_enter_number_manually"), 
   743         // Sets the "Cancel"-action/button
 
   774             KOtherNumber );
 
   744         HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_cancel"));
 
   775     dialog->setContentWidget(list);
 
   745         dialog->addAction(cancelAction);
 
   776     
   746         QObject::connect(cancelAction, 
   777     // Connect list item activation signal to close the popup
 
   747                 SIGNAL(triggered(bool)), 
   778     QObject::connect(list, 
   748                 dialog, 
   779             SIGNAL(activated(HbListWidgetItem*)), 
   749                 SLOT(close()));
 
   780             dialog.data(), 
   750         
   781             SLOT(close()), 
   751         dialog->open(this, SLOT(voiceNumberListQueryClosed(HbAction *))); 
   782             Qt::UniqueConnection);
 
   752         
   783     
   753         QPointer<QObject> guard = this;
 
   784     // Sets the "Cancel"-action/button
 
   754         m_eventLoop->exec(); 
   785     HbAction *cancelAction = new HbAction(hbTrId(
 
   755         if (guard.isNull()) {
 
   786             "txt_common_button_cancel"), 
   756             requestOK = false;
 
   787             dialog.data());
 
   757         } else if (!m_divertNumber.isEmpty()) {
 
   788     dialog->addAction(cancelAction);
 
   758             result = m_divertNumber;
 
   789     QObject::connect(cancelAction, 
   759             requestOK = true;
 
   790             SIGNAL(triggered(bool)), 
   760         }    
   791             dialog.data(), 
   761     }
 
   792             SLOT(close()));
 
   762     
   793     
   763     DPRINT << ": OUT : result:" << result;
 
   794     dialog->open(this, SLOT(voiceNumberListQueryClosed(HbAction *)));
 
   764     DPRINT << ": OUT : requestOK :" << requestOK;
 
   795     m_dialog = dialog.take();
 
   765     return requestOK;
 
   796     DPRINT << ": OUT";
 
   766 }
 
   797 }
 
   767 
   798 
   768 /*!
 
   799 /*!
 
   769     CpDivertPluginGroup::voiceNumberListQueryClosed()
 
   800     CpDivertPluginGroup::voiceNumberListQueryClosed()
 
   770 */
 
   801 */
 
   771 void CpDivertPluginGroup::voiceNumberListQueryClosed(HbAction* action)
 
   802 void CpDivertPluginGroup::voiceNumberListQueryClosed(HbAction* action)
 
   772 {
 
   803 {
 
   773     DPRINT << ": IN";
 
   804     DPRINT << ": IN";
 
   774     
   805     HbListWidget *list(NULL);
 
   775     bool exitLoop(true); 
   806     m_divertCommand.iNumber.clear();
 
       
   807     bool processNextPhase(true);
 
       
   808     
       
   809     if (m_dialog) {
 
       
   810         bool err = QObject::disconnect(m_dialog->contentWidget(), 
       
   811             SIGNAL(activated(HbListWidgetItem*)), 
       
   812             m_dialog, 
       
   813             SLOT(close()));
 
       
   814         list = qobject_cast<HbListWidget*>(m_dialog->contentWidget());
 
       
   815         m_dialog->deleteLater();
 
       
   816         m_dialog = NULL;
 
       
   817     }
 
   776     
   818     
   777     // Enter if cancel wasn't selected 
   819     // Enter if cancel wasn't selected 
   778     if (!action) {  
   820     if (!action && list) {
 
   779         // Update the view with selected text
 
   821         // Update the view with selected text
 
   780         QString data = m_voiceNumberList->currentItem()->data().toString();
 
   822         QString data = list->currentItem()->data().toString();
 
       
   823         QString text = list->currentItem()->text();
 
       
   824 
   781         DPRINT << ": data: " << data; 
   825         DPRINT << ": data: " << data; 
   782         
   826         DPRINT << ": text: " << text; 
   783         if (data == KVoiceMail) {
 
   827 
   784             m_callDivertingWrapper->getVoiceMailBoxNumber(m_divertNumber);
 
   828         if (data == KOtherNumber) {
 
   785             if (!m_divertNumber.isEmpty()) {
 
   829             DPRINT << ": open popUpNumberEditor";
 
   786                 DPRINT << ": voicemailboxnumber found";
 
   830             processNextPhase = false;
 
   787             }
 
   831             popUpNumberEditor(hbTrId("txt_phone_info_number"));
 
   788             
   832         } else if (text == hbTrId("txt_phone_setlabel_voice_mbx")) {
 
   789             m_eventLoop->quit();
 
   833             DPRINT << ": get voicemailboxnumber";
 
   790             
   834             m_callDivertingWrapper->getVoiceMailBoxNumber(
 
   791         } else if (data == KOtherNumber) {
 
   835                 m_divertCommand.iNumber, ServiceGroupVoice);
 
   792                 // Event loop is terminated by popUpNumberEditorClosed
 
   836             if (m_divertCommand.iNumber.isEmpty()) {
 
   793                 exitLoop = false;
 
   837                 DPRINT << ": voicemailboxnumber query";
 
   794                 
   838                 m_callDivertingWrapper->queryVoiceMailBoxNumber(
 
   795                 DPRINT << ": open popUpNumberEditor";                
   839                     m_divertCommand.iNumber, ServiceGroupVoice);
 
   796                 popUpNumberEditor(hbTrId("txt_phone_info_number"), m_divertNumber);
 
   840             }
 
   797         } else {
 
   841         } else if (text == hbTrId("txt_phone_setlabel_video_mbx")) {
 
       
   842             DPRINT << ": get videomailboxnumber";
 
       
   843             m_callDivertingWrapper->getVoiceMailBoxNumber(
 
       
   844                 m_divertCommand.iNumber, ServiceGroupData);
 
       
   845             if (m_divertCommand.iNumber.isEmpty()) {
 
       
   846                 DPRINT << ": videomailboxnumber query";
 
       
   847                 m_callDivertingWrapper->queryVoiceMailBoxNumber(
 
       
   848                     m_divertCommand.iNumber, ServiceGroupData);
 
       
   849             }
 
       
   850         }  else {
 
   798             //TODO if matched contact name not work
 
   851             //TODO if matched contact name not work
 
   799             DPRINT << ": else";
 
   852             DPRINT << ": else";
 
   800             m_divertNumber = data;
 
   853             m_divertCommand.iNumber = data;
 
   801         }        
   854         }        
   802         
   855     }
 
   803     }
 
   856     DPRINT << ": processNextPhase: " << processNextPhase; 
   804     
   857     DPRINT << ": m_divertCommand.iNumber: " << m_divertCommand.iNumber; 
   805     if (exitLoop) {
 
   858     if (processNextPhase) {
 
   806         DPRINT << ": quit eventloop";
 
   859         if (m_divertCommand.iNumber.isEmpty()) {
 
   807         m_eventLoop->quit();
 
   860             nextPhaseForActivateDivert(false);
 
       
   861         } else {
 
       
   862             nextPhaseForActivateDivert(true);
 
       
   863         }
 
   808     }
 
   864     }
 
   809     
   865     
   810     DPRINT << ": OUT";
 
   866     DPRINT << ": OUT";
 
   811 }
 
   867 }
 
   812 
   868 
   813 /*!
 
   869 /*!
 
   814   CpDivertPluginGroup::popUpNumberEditor.
 
   870   CpDivertPluginGroup::popUpNumberEditor.
 
   815  */
 
   871  */
 
   816 void CpDivertPluginGroup::popUpNumberEditor(
 
   872 void CpDivertPluginGroup::popUpNumberEditor(
 
   817         const QString& heading, QString& result)
 
   873         const QString& heading)
 
   818 {
 
   874 {
 
   819     DPRINT << ": IN";
 
   875     DPRINT << ": IN";
 
   820 
   876 
   821     Q_UNUSED(result); 
   877     if (m_dialog) {
 
   822     
   878         m_dialog->deleteLater();
 
   823     HbDialog *dialog = createDialog(heading);
 
   879         m_dialog = NULL;
 
   824 
   880     }
 
   825     m_voiceNumberEditor = new HbLineEdit(dialog);
 
   881     QScopedPointer<HbDialog> dialog(createDialog(heading));
 
   826     m_voiceNumberEditor->setInputMethodHints(Qt::ImhDialableCharactersOnly);    
   882 
   827     dialog->setContentWidget(m_voiceNumberEditor);
 
   883     HbLineEdit *editor = new HbLineEdit(dialog.data());
 
   828     
   884     editor->setInputMethodHints(Qt::ImhDialableCharactersOnly);    
   829     HbAction *okAction = new HbAction(hbTrId("txt_common_button_ok"));
 
   885     //Ownership is transferred
 
       
   886     dialog->setContentWidget(editor);
 
       
   887     
       
   888     HbAction *okAction = new HbAction(
 
       
   889             hbTrId("txt_common_button_ok"), 
       
   890             dialog.data());
 
   830     dialog->addAction(okAction);
 
   891     dialog->addAction(okAction);
 
   831     
   892     
   832     HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_cancel"));
 
   893     HbAction *cancelAction = new HbAction(
 
       
   894             hbTrId("txt_common_button_cancel"), 
       
   895             dialog.data());
 
   833     dialog->addAction(cancelAction);
 
   896     dialog->addAction(cancelAction);
 
   834     
       
   835     dialog->open(this, SLOT(popUpNumberEditorClosed(HbAction*)));
 
   897     dialog->open(this, SLOT(popUpNumberEditorClosed(HbAction*)));
 
   836     
   898     m_dialog = dialog.take();
 
   837     DPRINT << ": OUT";
 
   899     DPRINT << ": OUT";
 
   838 }
 
   900 }
 
   839 
   901 
   840 /*!
 
   902 /*!
 
   841   CpDivertPluginGroup::popUpNumberEditorClosed.
 
   903   CpDivertPluginGroup::popUpNumberEditorClosed.
 
   842  */
 
   904  */
 
   843 void CpDivertPluginGroup::popUpNumberEditorClosed(HbAction* action)
 
   905 void CpDivertPluginGroup::popUpNumberEditorClosed(HbAction* action)
 
   844 {
 
   906 {
 
   845     DPRINT << ": IN";
 
   907     DPRINT << ": IN";
 
   846     
       
   847     bool cancelled(true); 
   908     bool cancelled(true); 
   848     if (action) {
 
   909     if (action) {
 
   849         if (action->text() == hbTrId("txt_common_button_ok")) 
   910         if (action->text() == hbTrId("txt_common_button_ok")) {
 
   850             {
 
       
   851             cancelled = false;  
   911             cancelled = false;  
   852             DPRINT << ": ok selected";
 
   912             DPRINT << ": ok selected";
 
   853             }
 
   913         }
 
   854     }
 
   914     }
 
   855     
   915     
   856     if (!cancelled) {
 
   916     if (!cancelled) {
 
   857         m_divertNumber = m_voiceNumberEditor->text();
 
   917         HbLineEdit *editor = qobject_cast<HbLineEdit *>(m_dialog->contentWidget());
 
   858             DPRINT << ": m_divertNumber "
 
   918         if (editor) {
 
   859                 << m_divertNumber;
 
   919             m_divertCommand.iNumber = editor->text();
 
   860             if (m_divertNumber.isEmpty()) {
 
   920         }
 
   861                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId, 
   921         
   862                     hbTrId("txt_phone_info_invalid_phone_number"), HbMessageBox::MessageTypeWarning);
 
   922         DPRINT << ": m_divertCommand.iNumber "
 
   863             }
 
   923             << m_divertCommand.iNumber;
 
   864     }
 
   924         if (m_divertCommand.iNumber.isEmpty()) {
 
   865     
   925             CpPhoneNotes::instance()->showNotificationDialog(hbTrId("txt_phone_info_invalid_phone_number"));
 
   866     if (m_voiceNumberEditor) {
 
   926         }
 
   867         delete m_voiceNumberEditor;
 
   927     }
 
   868         m_voiceNumberEditor = NULL; 
   928     if (m_dialog) {
 
   869     } 
   929         m_dialog->deleteLater();
 
   870     
   930         m_dialog = NULL;
 
   871     m_eventLoop->quit();
 
   931     }
 
       
   932     
       
   933     nextPhaseForActivateDivert(!cancelled);
 
       
   934     
   872     DPRINT << ": OUT";
 
   935     DPRINT << ": OUT";
 
   873 }
 
   936 }
 
   874 
   937 
   875 /*!
 
   938 /*!
 
   876   CpDivertPluginGroup::setCallDiverting.
 
   939   CpDivertPluginGroup::setCallDiverting.
 
   888     int result = m_callDivertingWrapper->setCallDiverting(
 
   951     int result = m_callDivertingWrapper->setCallDiverting(
 
   889             command, bscParam(command.iServiceGroup));
 
   952             command, bscParam(command.iServiceGroup));
 
   890     if (0 == result) {
 
   953     if (0 == result) {
 
   891         if (!CpPhoneNotes::instance()->noteShowing()) {
 
   954         if (!CpPhoneNotes::instance()->noteShowing()) {
 
   892             CpPhoneNotes::instance()->showGlobalProgressNote(
 
   955             CpPhoneNotes::instance()->showGlobalProgressNote(
 
   893                     m_activeProgressNoteId, hbTrId("txt_phone_info_requesting"));
 
   956                     m_activeProgressNoteId, hbTrId("txt_common_info_requesting"));
 
   894         }
 
   957         }
 
   895     } else {
 
   958     } else {
 
   896         handleDivertingError(result);
 
   959         handleDivertingError(result);
 
   897     }
 
   960     }
 
   898     
   961     
   900 }
 
   963 }
 
   901 
   964 
   902 /*!
 
   965 /*!
 
   903   CpDivertPluginGroup::popUpTimerQuery.
 
   966   CpDivertPluginGroup::popUpTimerQuery.
 
   904  */
 
   967  */
 
   905 bool CpDivertPluginGroup::popUpTimerQuery(int &timeout) 
   968 void CpDivertPluginGroup::popUpTimerQuery() 
   906 {
 
   969 {
 
   907     DPRINT << ": IN";
 
   970     DPRINT << ": IN";
 
   908     Q_UNUSED(timeout); 
   971     
   909     
   972     m_divertCommand.iNoReplyTimer = 0; 
   910     bool requestOK(false);
 
   973     
   911     m_divertTimeout = 0; 
   974     QScopedPointer<HbDialog> dialog(createDialog(hbTrId("txt_phone_title_delay")));
 
   912     
   975     HbListWidget *list = new HbListWidget(dialog.data());
 
   913     if (!m_eventLoop->isRunning()) {
 
   976     
   914         HbDialog *dialog = createDialog(hbTrId("txt_phone_title_delay"));
 
   977     HbParameterLengthLimiter pluralLimiter;
 
   915         
   978     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 5);
 
   916         if (m_popupTimerList) {
 
   979     addItemToListWidget(list, pluralLimiter, 5 );
 
   917             m_popupTimerList = new HbListWidget(dialog);
 
   980     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 10);
 
   918             
   981     addItemToListWidget(list, pluralLimiter, 10);
 
   919             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_5_seconds"), 5 );
 
   982     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 15);
 
   920             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_10_seconds"), 10);
 
   983     addItemToListWidget(list, pluralLimiter, 15);
 
   921             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_15_seconds"), 15);
 
   984     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 20);
 
   922             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_20_seconds"), 20);
 
   985     addItemToListWidget(list, pluralLimiter, 20);
 
   923             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_25_seconds"), 25);
 
   986     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 25);
 
   924             addItemToListWidget(m_popupTimerList, hbTrId("txt_phone_list_30_seconds"), 30);
 
   987     addItemToListWidget(list, pluralLimiter, 25);
 
   925             
   988     pluralLimiter = HbParameterLengthLimiter("txt_phone_list_ln_seconds", 30);
 
   926             // Connect list item activation signal to close the popup
 
   989     addItemToListWidget(list, pluralLimiter, 30);
 
   927             QObject::connect(
 
   990     
   928                     m_popupTimerList, SIGNAL(activated(HbListWidgetItem*)), 
   991     // Connect list item activation signal to close the popup
 
   929                     dialog, SLOT(close()), 
   992     QObject::connect(
 
   930                     Qt::UniqueConnection);
 
   993             list, SIGNAL(activated(HbListWidgetItem*)), 
   931         }
 
   994             dialog.data(), SLOT(close()), 
   932         
   995             Qt::UniqueConnection);
 
   933         // Sets the "Cancel"-action/button
 
   996     
   934         HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_cancel"));
 
   997     // Sets the "Cancel"-action/button
 
   935         dialog->addAction(cancelAction);
 
   998     HbAction *cancelAction = new HbAction(hbTrId("txt_common_button_cancel"));
 
   936         dialog->setContentWidget(m_popupTimerList);
 
   999     dialog->addAction(cancelAction);
 
   937     
  1000     dialog->setContentWidget(list);
 
   938         dialog->open(this, SLOT(popUpTimerQueryClosed(HbAction *))); 
  1001 
   939         
  1002     dialog->open(this, SLOT(popUpTimerQueryClosed(HbAction *)));
 
   940         QPointer<QObject> guard = this;
 
  1003     if (m_dialog) {
 
   941         m_eventLoop->exec(); 
  1004         m_dialog->deleteLater();
 
   942         if (guard.isNull()) {
 
  1005         m_dialog = NULL;
 
   943             requestOK = false;
 
  1006     }
 
   944         } else if (m_divertTimeout > 0) {
 
  1007     m_dialog = dialog.take();
 
   945             requestOK = true;
 
  1008     
   946         }
 
  1009     DPRINT << ": OUT";
 
   947     }
 
       
   948     
       
   949     DPRINT << ": OUT : requestOK :" << requestOK;
 
       
   950     return requestOK;
 
       
   951 }
 
  1010 }
 
   952 
  1011 
   953 /*!
 
  1012 /*!
 
   954   CpDivertPluginGroup::popUpTimerQueryClosed.
 
  1013   CpDivertPluginGroup::popUpTimerQueryClosed.
 
   955  */
 
  1014  */
 
   956 void CpDivertPluginGroup::popUpTimerQueryClosed(HbAction* action)
 
  1015 void CpDivertPluginGroup::popUpTimerQueryClosed(HbAction* action)
 
   957 {
 
  1016 {
 
       
  1017     DPRINT << ": IN";
 
       
  1018     
   958     // If not cancel action selected 
  1019     // If not cancel action selected 
       
  1020     bool cancelled(true);
 
   959     if (!action) {
 
  1021     if (!action) {
 
       
  1022         cancelled = false;
 
   960         // Update the view with selected text
 
  1023         // Update the view with selected text
 
   961         if (m_popupTimerList->currentItem()) {
 
  1024         HbListWidget *list = qobject_cast<HbListWidget*>(m_dialog->contentWidget());
 
   962             m_divertTimeout = 
  1025         if (list && list->currentItem()) {
 
   963                     m_popupTimerList->currentItem()->data().toInt();
 
  1026             m_divertCommand.iNoReplyTimer = 
   964         }
 
  1027                     list->currentItem()->data().toInt();
 
   965     }
 
  1028         }
 
   966     else {
 
  1029     }
 
   967         DPRINT << ": Cancel";
 
  1030     
   968     }
 
  1031     if (m_dialog) {
 
   969 
  1032         m_dialog->deleteLater();
 
   970     DPRINT << ": quit eventloop";
 
  1033         m_dialog = NULL;
 
   971     m_eventLoop->quit();
 
  1034     }
 
   972 
  1035     
   973     DPRINT << ": OUT: timeout: " << m_divertTimeout;
 
  1036     nextPhaseForActivateDivert(!cancelled);
 
       
  1037 
       
  1038     DPRINT << ": OUT: timeout: " << m_divertCommand.iNoReplyTimer;
 
   974 }
 
  1039 }
 
   975 
  1040 
   976 
  1041 
   977 /*!
 
  1042 /*!
 
   978   CpDivertPluginGroup::bscParam.
 
  1043   CpDivertPluginGroup::bscParam.
 
  1002     
  1067     
  1003     if (serviceGroup & ServiceGroupData) {
 
  1068     if (serviceGroup & ServiceGroupData) {
 
  1004         bsc = AllBearer;
 
  1069         bsc = AllBearer;
 
  1005     }
 
  1070     }
 
  1006 
  1071 
  1007 
       
  1008     
       
  1009     DPRINT << ": OUT : bsc :" << bsc;
 
  1072     DPRINT << ": OUT : bsc :" << bsc;
 
  1010     return bsc;
 
  1073     return bsc;
 
  1011 }
 
  1074 }
 
  1012 
  1075 
  1013 /*!
 
  1076 /*!
 
  1072 void CpDivertPluginGroup::updateDependentDivertOptions(bool fetchFromNetwork)
 
  1135 void CpDivertPluginGroup::updateDependentDivertOptions(bool fetchFromNetwork)
 
  1073 {
 
  1136 {
 
  1074     DPRINT << ": IN";
 
  1137     DPRINT << ": IN";
 
  1075     
  1138     
  1076     // all calls divert activation deactivates automatically other diverts
 
  1139     // all calls divert activation deactivates automatically other diverts
 
  1077     QVariant itemState = m_DataItemVoiceAllCalls->contentWidgetData("state");
 
  1140     QVariant itemState = m_DataItemVoiceAllCalls->contentWidgetData("checkState");
 
  1078     if ((itemState.isValid()) && 
  1141     if ((itemState.isValid()) && 
  1079         (itemState.toInt() == CpDivertSelectionCustomitem::Enabled)) {
 
  1142         (itemState.toInt() == Qt::Checked)) {
 
  1080         deActivateDependentDivertOption(m_DataItemVoiceIfBusy);
 
  1143         deactivateDependentDivertOption(m_DataItemVoiceIfBusy);
 
  1081         deActivateDependentDivertOption(m_DataItemVoiceIfNotAnswered);
 
  1144         deactivateDependentDivertOption(m_DataItemVoiceIfNotAnswered);
 
  1082         deActivateDependentDivertOption(m_DataItemVoiceIfOutOfReach);
 
  1145         deactivateDependentDivertOption(m_DataItemVoiceIfOutOfReach);
 
  1083     } else {
 
  1146     } else {
 
  1084         // Must query data for diverts depending on all calls divert, because 
  1147         // Must query data for diverts depending on all calls divert, because 
  1085         // data may have been lost for registered diverts, which were 
  1148         // data may have been lost for registered diverts, which were 
  1086         // automatically deactivated due to the activation of all calls divert.
 
  1149         // automatically deactivated due to the activation of all calls divert.
 
  1087         activateDependentDivertOption(m_DataItemVoiceIfBusy, fetchFromNetwork);
 
  1150         activateDependentDivertOption(m_DataItemVoiceIfBusy, fetchFromNetwork);
 
  1088         activateDependentDivertOption(m_DataItemVoiceIfNotAnswered, fetchFromNetwork);
 
  1151         activateDependentDivertOption(m_DataItemVoiceIfNotAnswered, fetchFromNetwork);
 
  1089         activateDependentDivertOption(m_DataItemVoiceIfOutOfReach, fetchFromNetwork);
 
  1152         activateDependentDivertOption(m_DataItemVoiceIfOutOfReach, fetchFromNetwork);
 
  1090     }
 
  1153     }
 
  1091     
  1154     
  1092     // all calls divert activation deactivates automatically other diverts
 
  1155     // all calls divert activation deactivates automatically other diverts
 
  1093     itemState = m_DataItemVideoAllCalls->contentWidgetData("state");
 
  1156     itemState = m_DataItemVideoAllCalls->contentWidgetData("checkState");
 
  1094     if ((itemState.isValid()) && 
  1157     if ((itemState.isValid()) && 
  1095         (itemState.toInt() == CpDivertSelectionCustomitem::Enabled)) {
 
  1158         (itemState.toInt() == Qt::Checked)) {
 
  1096         deActivateDependentDivertOption(m_DataItemVideoIfBusy);
 
  1159         deactivateDependentDivertOption(m_DataItemVideoIfBusy);
 
  1097         deActivateDependentDivertOption(m_DataItemVideoIfNotAnswered);
 
  1160         deactivateDependentDivertOption(m_DataItemVideoIfNotAnswered);
 
  1098         deActivateDependentDivertOption(m_DataItemVideoIfOutOfReach);
 
  1161         deactivateDependentDivertOption(m_DataItemVideoIfOutOfReach);
 
  1099     } else {
 
  1162     } else {
 
  1100         // Must query data for diverts depending on all calls divert, because 
  1163         // Must query data for diverts depending on all calls divert, because 
  1101         // data may have been lost for registered diverts, which were 
  1164         // data may have been lost for registered diverts, which were 
  1102         // automatically deactivated due to the activation of all calls divert.
 
  1165         // automatically deactivated due to the activation of all calls divert.
 
  1103         activateDependentDivertOption(m_DataItemVideoIfBusy, fetchFromNetwork);
 
  1166         activateDependentDivertOption(m_DataItemVideoIfBusy, fetchFromNetwork);
 
  1110     
  1173     
  1111     DPRINT << ": OUT";
 
  1174     DPRINT << ": OUT";
 
  1112 }
 
  1175 }
 
  1113 
  1176 
  1114 /*!
 
  1177 /*!
 
  1115   CpDivertPluginGroup::deActivateDependentDivertOption.
 
  1178   CpDivertPluginGroup::deactivateDependentDivertOption.
 
  1116 */
 
  1179 */
 
  1117 void CpDivertPluginGroup::deActivateDependentDivertOption(
 
  1180 void CpDivertPluginGroup::deactivateDependentDivertOption(
 
  1118         CpDivertItemData* item) const
 
  1181         CpDivertItemData* item) const
 
  1119 {
 
  1182 {
 
  1120     QVariant itemState = item->contentWidgetData("state");
 
  1183     DPRINT << ": IN";
 
  1121     if ((itemState.isValid()) && 
  1184     
  1122         (itemState == CpDivertSelectionCustomitem::Enabled)) {
 
  1185     QVariant itemState = item->contentWidgetData("checkState");
 
  1123         item->setContentWidgetData(
 
  1186     if ((itemState.isValid()) && (itemState == Qt::Checked)) {
 
  1124             "state", CpDivertSelectionCustomitem::Deactivated);
 
  1187         item->setContentWidgetData("checkState", Qt::Unchecked);
 
       
  1188         item->setContentWidgetData("text", QString(""));
 
       
  1189         
       
  1190         if (!item->description().isEmpty()) {
 
       
  1191             item->setDescription("");
 
       
  1192         }
 
  1125     }
 
  1193     }
 
  1126     item->setEnabled(false);
 
  1194     item->setEnabled(false);
 
       
  1195     
       
  1196     DPRINT << ": OUT";
 
  1127 }
 
  1197 }
 
  1128 
  1198 
  1129 /*!
 
  1199 /*!
 
  1130   CpDivertPluginGroup::activateDependentDivertOption.
 
  1200   CpDivertPluginGroup::activateDependentDivertOption.
 
  1131 */
 
  1201 */
 
  1132 void CpDivertPluginGroup::activateDependentDivertOption(
 
  1202 void CpDivertPluginGroup::activateDependentDivertOption(
 
  1133         CpDivertItemData* item, bool fetchFromNetwork)
 
  1203         CpDivertItemData* item, bool fetchFromNetwork)
 
  1134 {
 
  1204 {
 
  1135     if ((CpDivertSelectionCustomitem::Deactivated == 
  1205     DPRINT << ": IN";
 
  1136             item->contentWidgetData("state").toInt()) &&
 
  1206     
       
  1207     if ((Qt::Unchecked == item->contentWidgetData("checkState").toInt()) &&
 
  1137             fetchFromNetwork) {
 
  1208             fetchFromNetwork) {
 
  1138         addToDivertingRequestQueue(
 
  1209         addToDivertingRequestQueue(CheckDivertStatus, *item);
 
  1139             CheckDivertStatus, *item);
 
       
  1140     }
 
  1210     }
 
  1141     item->setEnabled(true);
 
  1211     item->setEnabled(true);
 
       
  1212     
       
  1213     DPRINT << ": OUT";
 
  1142 }
 
  1214 }
 
  1143 
  1215 
  1144 /*!
 
  1216 /*!
 
  1145   CpDivertPluginGroup::updateNotAvailableDivertOption.
 
  1217   CpDivertPluginGroup::updateNotAvailableDivertOption.
 
  1146  */
 
  1218  */
 
  1150     
  1222     
  1151     // We must check that both states & numbers match amongst CFB, CRNry and 
  1223     // We must check that both states & numbers match amongst CFB, CRNry and 
  1152     // CFNrc before concluding that not available divert is enabled, because
 
  1224     // CFNrc before concluding that not available divert is enabled, because
 
  1153     // some networks may not return divert number for inactive diverts.
 
  1225     // some networks may not return divert number for inactive diverts.
 
  1154     int cfbState = 
  1226     int cfbState = 
  1155         m_DataItemVoiceIfBusy->contentWidgetData("state").toInt();
 
  1227         m_DataItemVoiceIfBusy->contentWidgetData("checkState").toInt();
 
  1156     int cfnryState = 
  1228     int cfnryState = 
  1157         m_DataItemVoiceIfNotAnswered->contentWidgetData("state").toInt();
 
  1229         m_DataItemVoiceIfNotAnswered->contentWidgetData("checkState").toInt();
 
  1158     int cfnrcState = 
  1230     int cfnrcState = 
  1159         m_DataItemVoiceIfOutOfReach->contentWidgetData("state").toInt();
 
  1231         m_DataItemVoiceIfOutOfReach->contentWidgetData("checkState").toInt();
 
  1160     QVariant cfbNumber = 
  1232     QVariant cfbNumber = 
  1161         m_DataItemVoiceIfBusy->contentWidgetData("number");
 
  1233         m_DataItemVoiceIfBusy->contentWidgetData("text");
 
  1162     QVariant cfnryNumber = 
  1234     QVariant cfnryNumber = 
  1163         m_DataItemVoiceIfNotAnswered->contentWidgetData("number");
 
  1235         m_DataItemVoiceIfNotAnswered->contentWidgetData("text");
 
  1164     QVariant cfnrcNumber = 
  1236     QVariant cfnrcNumber = 
  1165         m_DataItemVoiceIfOutOfReach->contentWidgetData("number");
 
  1237         m_DataItemVoiceIfOutOfReach->contentWidgetData("text");
 
  1166     
  1238     
  1167     if ((cfbNumber == cfnryNumber) && (cfbNumber == cfnrcNumber) &&
 
  1239     if ((cfbNumber == cfnryNumber) && (cfbNumber == cfnrcNumber) &&
 
  1168         (cfbState == cfnryState) && (cfbState == cfnrcState)) {
 
  1240         (cfbState == cfnryState) && (cfbState == cfnrcState)) {
 
  1169         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1241         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1170             "number", m_DataItemVoiceIfBusy->contentWidgetData("number"));
 
  1242             "text", m_DataItemVoiceIfBusy->contentWidgetData("text"));
 
  1171         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1243         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1172             "timeout", m_DataItemVoiceIfNotAnswered->contentWidgetData("timeout"));
 
  1244             "checkState", m_DataItemVoiceIfBusy->contentWidgetData("checkState"));
 
       
  1245     } else {
 
       
  1246         m_DataItemVoiceIfNotAvailable->setContentWidgetData("text", "");
 
  1173         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1247         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
  1174             "state", m_DataItemVoiceIfBusy->contentWidgetData("state"));
 
  1248             "checkState", Qt::Unchecked);
 
  1175     } else {
 
       
  1176         m_DataItemVoiceIfNotAvailable->setContentWidgetData("number", "");
 
       
  1177         m_DataItemVoiceIfNotAvailable->setContentWidgetData("timeout", 0);
 
       
  1178         m_DataItemVoiceIfNotAvailable->setContentWidgetData(
 
       
  1179             "state", CpDivertSelectionCustomitem::Disabled);
 
       
  1180 
  1249 
  1181     }
 
  1250     }
 
  1182     // Item dimming
 
  1251     // Item dimming
 
  1183     m_DataItemVoiceIfNotAvailable->setEnabled(
 
  1252     m_DataItemVoiceIfNotAvailable->setEnabled(
 
  1184             m_DataItemVoiceIfBusy->isEnabled() &&
 
  1253             m_DataItemVoiceIfBusy->isEnabled() &&
 
  1188     
  1257     
  1189     // We must check that both states & numbers match amongst CFB, CRNry and 
  1258     // We must check that both states & numbers match amongst CFB, CRNry and 
  1190     // CFNrc before concluding that not available divert is enabled, because
 
  1259     // CFNrc before concluding that not available divert is enabled, because
 
  1191     // some networks may not return divert number for inactive diverts.
 
  1260     // some networks may not return divert number for inactive diverts.
 
  1192     cfbState = 
  1261     cfbState = 
  1193         m_DataItemVideoIfBusy->contentWidgetData("state").toInt();
 
  1262         m_DataItemVideoIfBusy->contentWidgetData("checkState").toInt();
 
  1194     cfnryState = 
  1263     cfnryState = 
  1195         m_DataItemVideoIfNotAnswered->contentWidgetData("state").toInt();
 
  1264         m_DataItemVideoIfNotAnswered->contentWidgetData("checkState").toInt();
 
  1196     cfnrcState = 
  1265     cfnrcState = 
  1197         m_DataItemVideoIfOutOfReach->contentWidgetData("state").toInt();
 
  1266         m_DataItemVideoIfOutOfReach->contentWidgetData("checkState").toInt();
 
  1198     cfbNumber = 
  1267     cfbNumber = 
  1199         m_DataItemVideoIfBusy->contentWidgetData("number");
 
  1268         m_DataItemVideoIfBusy->contentWidgetData("text");
 
  1200     cfnryNumber = 
  1269     cfnryNumber = 
  1201         m_DataItemVideoIfNotAnswered->contentWidgetData("number");
 
  1270         m_DataItemVideoIfNotAnswered->contentWidgetData("text");
 
  1202     cfnrcNumber = 
  1271     cfnrcNumber = 
  1203         m_DataItemVideoIfOutOfReach->contentWidgetData("number");
 
  1272         m_DataItemVideoIfOutOfReach->contentWidgetData("text");
 
  1204     
  1273     
  1205     if ((cfbNumber == cfnryNumber) && (cfbNumber == cfnrcNumber) &&
 
  1274     if ((cfbNumber == cfnryNumber) && (cfbNumber == cfnrcNumber) &&
 
  1206         (cfbState == cfnryState) && (cfbState == cfnrcState)) {
 
  1275         (cfbState == cfnryState) && (cfbState == cfnrcState)) {
 
  1207         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1276         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1208             "number", m_DataItemVideoIfBusy->contentWidgetData("number"));
 
  1277             "text", m_DataItemVideoIfBusy->contentWidgetData("text"));
 
  1209         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1278         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1210             "timeout", m_DataItemVideoIfNotAnswered->contentWidgetData("timeout"));
 
  1279             "checkState", m_DataItemVideoIfBusy->contentWidgetData("checkState"));
 
       
  1280     } else {
 
       
  1281         m_DataItemVideoIfNotAvailable->setContentWidgetData("text", "");
 
  1211         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1282         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
  1212             "state", m_DataItemVideoIfBusy->contentWidgetData("state"));
 
  1283             "checkState", Qt::Unchecked);
 
  1213     } else {
 
       
  1214         m_DataItemVideoIfNotAvailable->setContentWidgetData("number", "");
 
       
  1215         m_DataItemVideoIfNotAvailable->setContentWidgetData("timeout", 0);
 
       
  1216         m_DataItemVideoIfNotAvailable->setContentWidgetData(
 
       
  1217             "state", CpDivertSelectionCustomitem::Disabled);
 
       
  1218 
       
  1219     }
 
  1284     }
 
  1220     
  1285     
  1221     // Item dimming
 
  1286     // Item dimming
 
  1222     m_DataItemVideoIfNotAvailable->setEnabled(
 
  1287     m_DataItemVideoIfNotAvailable->setEnabled(
 
  1223             m_DataItemVideoIfBusy->isEnabled() &&
 
  1288             m_DataItemVideoIfBusy->isEnabled() &&
 
  1225             m_DataItemVideoIfOutOfReach->isEnabled()); 
  1290             m_DataItemVideoIfOutOfReach->isEnabled()); 
  1226     
  1291     
  1227     DPRINT << ": OUT";
 
  1292     DPRINT << ": OUT";
 
  1228 }
 
  1293 }
 
  1229 
  1294 
       
  1295 void CpDivertPluginGroup::nextPhaseForActivateDivert(bool ok)
 
       
  1296 {
 
       
  1297     DPRINT << ": IN";
 
       
  1298     
       
  1299     if (ok) {
 
       
  1300         switch (m_activateDivertPhase) {
 
       
  1301             case PopUpVoiceNumberListQueryPhase: {
 
       
  1302                 CpDivertRequestQueueItem request = m_divertRequestQueue.head();
 
       
  1303                 if (request.item->property("needTimeoutInfo").toBool()) {
 
       
  1304                     m_activateDivertPhase = PopUpTimerQueryPhase;
 
       
  1305                     popUpTimerQuery();
 
       
  1306                 } else {
 
       
  1307                     m_activateDivertPhase = NonePhase;
 
       
  1308                     setCallDiverting(m_divertCommand);
 
       
  1309                     }
 
       
  1310             }
 
       
  1311                 break;
 
       
  1312             case PopUpTimerQueryPhase: {
 
       
  1313                 m_activateDivertPhase = NonePhase;
 
       
  1314                 setCallDiverting(m_divertCommand);
 
       
  1315             }
 
       
  1316             default:
 
       
  1317                 DPRINT << "Error: unknown enum value";
 
       
  1318                 break;
 
       
  1319         }
 
       
  1320     } else {
 
       
  1321         // Query was cancelled
 
       
  1322         revertItemData(
 
       
  1323             m_divertCommand.iServiceGroup, 
       
  1324             m_divertCommand.iCondition);
 
       
  1325         m_divertRequestQueue.clear();
 
       
  1326         m_activateDivertPhase = NonePhase;
 
       
  1327     }
 
       
  1328     
       
  1329     DPRINT << ": OUT";
 
       
  1330 }
 
       
  1331 
       
  1332 /*!
 
       
  1333   CpDivertPluginGroup::itemShown.
 
       
  1334  */
 
       
  1335 bool CpDivertPluginGroup::isDivertSettingsItem(HbDataFormModelItem* modelItem) {
 
       
  1336     return (
 
       
  1337         modelItem == m_DataItemVoiceAllCalls ||
 
       
  1338         modelItem == m_DataItemVoiceIfBusy ||
 
       
  1339         modelItem == m_DataItemVoiceIfNotAnswered ||
 
       
  1340         modelItem == m_DataItemVoiceIfOutOfReach ||
 
       
  1341         modelItem == m_DataItemVoiceIfNotAvailable ||
 
       
  1342         
       
  1343         modelItem == m_DataItemVideoAllCalls ||
 
       
  1344         modelItem == m_DataItemVideoIfBusy ||
 
       
  1345         modelItem == m_DataItemVideoIfNotAnswered ||
 
       
  1346         modelItem == m_DataItemVideoIfOutOfReach ||
 
       
  1347         modelItem == m_DataItemVideoIfNotAvailable
 
       
  1348     );
 
       
  1349 }
 
       
  1350 
  1230 // End of File. 
  1351 // End of File.
FCL/sf/app/phone