src/PhnSettingsCallForwardWaitBarrForm.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file    PhnSettingsCallForwardWaitBarrForm.cpp
  19  * @brief   Call forwarding form
  20  */
  21 #include <FApp.h>
  22 #include "PhnAppUtility.h"
  23 #include "PhnSettingsCallForwardWaitBarrForm.h"
  24 #include "PhnSettingsConstants.h"
  25 #include "PhnSettingsPresentationModel.h"
  26 #include "PhnSceneRegister.h"
  27 #include "PhnTypes.h"
  28
  29 using namespace Tizen::App;
  30 using namespace Tizen::Base;
  31 using namespace Tizen::Base::Collection;
  32 using namespace Tizen::Base::Runtime;
  33 using namespace Tizen::Graphics;
  34 using namespace Tizen::Ui;
  35 using namespace Tizen::Ui::Controls;
  36 using namespace Tizen::Ui::Scenes;
  37
  38 //constants
  39 const int IDI_GROUP_TOTALCOUNT = 1;
  40 static const wchar_t* IDL_SETTINGS_CALL_FORWARD_WAIT_BARRING_FORM = L"IDL_SETTINGS_CALL_FORWARD_WAIT_BARRING_FORM";
  41 static const wchar_t* IDC_SLIDER_CHECHBUTTON = L"IDC_SLIDER_CHECHBUTTON";
  42
  43 SettingsCallForwardWaitBarrForm::SettingsCallForwardWaitBarrForm(FormType formType)
  44                 : __formType(formType)
  45                 , __pSettingsPresentor(null)
  46                 , __pErrorMsgPopup(null)
  47                 , __isCallForwardAlwaysActivated(false)
  48                 , __pAnimationFrameList(null)
  49                 , __isCallWaitingStatusAvailable(false)
  50                 , __isCallWaitingEnabled(false)
  51 {
  52 }
  53
  54 SettingsCallForwardWaitBarrForm::~SettingsCallForwardWaitBarrForm(void)
  55 {
  56 }
  57
  58 void
  59 SettingsCallForwardWaitBarrForm::Initialize(void)
  60 {
  61         Construct(IDL_SETTINGS_CALL_FORWARD_WAIT_BARRING_FORM);
  62 }
  63
  64 result
  65 SettingsCallForwardWaitBarrForm::OnInitializing(void)
  66 {
  67         result r = E_SUCCESS;
  68
  69         __pSettingsPresentor = SettingsPresentationModel::GetInstance();
  70         //set Title
  71         Header* pHeader = GetHeader();
  72         if (pHeader != null)
  73         {
  74                 String title(L"");
  75                 switch (__formType)
  76                 {
  77                 case FORMTYPE_CALLFORWARDING_TYPE:
  78                 {
  79                         title.Append(AppUtility::GetResourceString(IDS_SETTING_FORWARD_CALLTYPE_TITLE));
  80                 }
  81                 break;
  82
  83                 case FORMTYPE_CALLBARRING_TYPE:
  84                 {
  85                         title.Append(AppUtility::GetResourceString(IDS_SETTING_BARRING_CALLTYPE_TITLE));
  86                 }
  87                 break;
  88
  89                 case FORMTYPE_VOICE_CALLFORWARDING:
  90                 {
  91                         title.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEFORWARD_OPTIONS_TITLE));
  92                 }
  93                 break;
  94
  95                 case FORMTYPE_VOICE_CALLBARRING:
  96                 {
  97                         title.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_OPTIONS_TITLE));
  98                 }
  99                 break;
 100
 101                 case FORMTYPE_CALL_WAITING:
 102                 {
 103                         title.Append(AppUtility::GetResourceString(IDS_SETTING_WAITING_OPTIONS_TITLE));
 104                 }
 105                 break;
 106
 107                 default:
 108                         break;
 109                 }
 110                 pHeader->SetTitleText(title);
 111         }
 112
 113         // Setup back event listener
 114         SetFormBackEventListener(this);
 115         //Footer
 116         Footer* pFooter = GetFooter();
 117         if (pFooter)
 118         {
 119                 pFooter->SetButtonColor(BUTTON_ITEM_STATUS_NORMAL, pFooter->GetColor());
 120         }
 121
 122         ConstructAnimationList();
 123         //initialize table view
 124         r = InitializeGroupedTableView();
 125
 126         return r;
 127 }
 128
 129 result
 130 SettingsCallForwardWaitBarrForm::OnTerminating(void)
 131 {
 132         result r = E_SUCCESS;
 133         __pSettingsPresentor = null;
 134
 135         if(__pAnimationFrameList != null)
 136         {
 137                 __pAnimationFrameList->RemoveAll();
 138                 delete __pAnimationFrameList;
 139                 __pAnimationFrameList = null;
 140         }
 141         return r;
 142 }
 143
 144 void
 145 SettingsCallForwardWaitBarrForm::ConstructAnimationList(void)
 146 {
 147         //Check if already created
 148         if(__pAnimationFrameList != null)
 149         {
 150                 return;
 151         }
 152         // Create AnimationList
 153         __pAnimationFrameList = new (std::nothrow) ArrayList(SingleObjectDeleter);
 154         __pAnimationFrameList->Construct();
 155
 156         // Create Bitmap
 157         AppResource *pAppResource = Application::GetInstance()->GetAppResource();
 158         if (pAppResource != null)
 159         {
 160                 for (int iconIndex = 1; iconIndex <= 30; iconIndex++)
 161                 {
 162                         //construct bitmap path
 163                         String bitmapPath(IDB_PROCESSING_ICONS);
 164                         String number(L"");
 165                         if(iconIndex < 10)
 166                         {
 167                                 bitmapPath.Append(0);
 168                         }
 169                         bitmapPath.Append(iconIndex);
 170                         bitmapPath.Append(L".png");
 171                         //Create Animation icons - fetch bitmap
 172                         Bitmap *pBitmap =  pAppResource->GetBitmapN(bitmapPath);
 173                         if(pBitmap != null)
 174                         {
 175                                 // Create AnimationFrames
 176                                 AnimationFrame *pAnimFrame = new (std::nothrow) AnimationFrame( *pBitmap,
 177                                                 (IDI_ANIM_DURATION / IDI_ANIM_PROGRESS_COUNT));
 178                                 __pAnimationFrameList->Add(pAnimFrame);
 179                                 delete pBitmap;
 180                                 pBitmap = null;
 181                         }
 182                 }
 183         }
 184 }
 185
 186 void
 187 SettingsCallForwardWaitBarrForm::OnActionPerformed(const Control& source, int actionId)
 188 {
 189         switch (actionId)
 190         {
 191         default:
 192                 break;
 193         }
 194 }
 195
 196 void
 197 SettingsCallForwardWaitBarrForm::OnFormBackRequested(Form& source)
 198 {
 199         SceneManager* pSceneManager = SceneManager::GetInstance();
 200         AppAssert(pSceneManager != null);
 201
 202         switch (__formType)
 203         {
 204         case FORMTYPE_CALLFORWARDING_TYPE:
 205         {
 206                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_MAIN_SETTING_MENU), null);
 207         }
 208         break;
 209
 210         case FORMTYPE_CALLBARRING_TYPE:
 211         case FORMTYPE_CALL_WAITING:
 212         {
 213                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_MORE_OPTIONS), null);
 214         }
 215         break;
 216
 217         case FORMTYPE_VOICE_CALLFORWARDING:
 218         {
 219                 //switch to form
 220                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALLTYPE_FORWARD), null);
 221         }
 222         break;
 223
 224         case FORMTYPE_VOICE_CALLBARRING:
 225         {
 226                 //switch to form
 227                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALLTYPE_BARRING), null);
 228         }
 229         break;
 230
 231         default:
 232                 break;
 233         }
 234 }
 235
 236 void
 237 SettingsCallForwardWaitBarrForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 238 {
 239         // Add your scene activate code here
 240         __pSettingsPresentor->AddSettingEventListener(this);
 241         int errorCode = ERROR_NONE;
 242         switch (__formType)
 243         {
 244         case FORMTYPE_VOICE_CALLFORWARDING:
 245         {
 246                 //fetch status
 247                 __isCallForwardAlwaysActivated = false;
 248                 errorCode = __pSettingsPresentor->GetCallForwardStatus(CALL_FORWARD_ALL);
 249                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 250                 errorCode = __pSettingsPresentor->GetCallForwardStatus(CALL_FORWARD_BUSY);
 251                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 252                 errorCode = __pSettingsPresentor->GetCallForwardStatus(CALL_FORWARD_NO_REPLY);
 253                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 254                 errorCode = __pSettingsPresentor->GetCallForwardStatus(CALL_FORWARD_NOT_REACHABLE);
 255                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 256         }
 257         break;
 258
 259         case FORMTYPE_VOICE_CALLBARRING:
 260         {
 261                 //fetch status
 262                 errorCode = __pSettingsPresentor->GetCallBarringStatus(CALL_BARRING_ALL_OUTGOING);
 263                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 264                 errorCode = __pSettingsPresentor->GetCallBarringStatus(CALL_BARRING_INTERNATIONAL_OUTGOING);
 265                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 266                 errorCode = __pSettingsPresentor->GetCallBarringStatus(CALL_BARRING_INTERNATIONAL_EXCEPT_HOME);
 267                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 268                 errorCode = __pSettingsPresentor->GetCallBarringStatus(CALL_BARRING_ALL_INCOMING);
 269                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 270                 errorCode = __pSettingsPresentor->GetCallBarringStatus(CALL_BARRING_INCOMING_ROAMING);
 271                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 272         }
 273         break;
 274
 275         case FORMTYPE_CALL_WAITING:
 276         {
 277                 //fetch status
 278                 errorCode = __pSettingsPresentor->GetCallWaitingStatus();
 279                 TryCatch(errorCode == ERROR_NONE,,"TAPI error occurred");
 280         }
 281         break;
 282
 283         default:
 284                 break;
 285         }
 286
 287         return;
 288
 289 CATCH:
 290         //Show error message popup
 291         ShowErrorMessage(errorCode);
 292         //in case of TAPI error, un-check all items
 293         UncheckAllOptions();
 294         return;
 295 }
 296
 297 void
 298 SettingsCallForwardWaitBarrForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 299 {
 300         // Add your scene de-activate code here
 301         __pSettingsPresentor->RemoveSettingEventListener();
 302 }
 303
 304 /////////////////////////////////////////////////////////////////////
 305 ////////////////// List View related functionality //////////////////
 306 /////////////////////////////////////////////////////////////////////
 307 result
 308 SettingsCallForwardWaitBarrForm::InitializeGroupedTableView(void)
 309 {
 310         result r = E_FAILURE;
 311         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 312         if (pMainMenuTableView != null)
 313         {
 314                 pMainMenuTableView->SetGroupedLookEnabled(true);
 315                 pMainMenuTableView->SetItemProvider(this);
 316                 r = pMainMenuTableView->AddGroupedTableViewItemEventListener(*this);
 317                 if( r == E_SUCCESS)
 318                 {
 319                         pMainMenuTableView->UpdateTableView();
 320                         //play processing animation
 321                         if(__formType == FORMTYPE_CALL_WAITING)
 322                         {
 323                                 pMainMenuTableView->RefreshItem(0, CALLWAITING_ITEM, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 324                         }
 325                 }
 326         }
 327         return r;
 328 }
 329
 330 void
 331 SettingsCallForwardWaitBarrForm::OnGroupedTableViewItemStateChanged(GroupedTableView& tableView, int groupIndex, int itemIndex, TableViewItem* pItem, TableViewItemStatus status)
 332 {
 333         switch (__formType)
 334         {
 335         case FORMTYPE_CALLFORWARDING_TYPE: //decide voice/video type for forwarding / barring
 336         case FORMTYPE_CALLBARRING_TYPE:
 337         {
 338                 HandleCallTypeSelected(itemIndex);
 339         }
 340         break;
 341
 342         case FORMTYPE_VOICE_CALLFORWARDING:
 343         {
 344                 HandleCallForwardingOptionSelected(itemIndex, status);
 345         }
 346         break;
 347
 348         case FORMTYPE_VOICE_CALLBARRING:
 349         {
 350                 HandleCallBarringOptionSelected(itemIndex, status);
 351         }
 352         break;
 353
 354         case FORMTYPE_CALL_WAITING:
 355         {
 356                 HandleCallWaitingOptionSelected(pItem, itemIndex, status);
 357         }
 358         break;
 359
 360         default:
 361                 break;
 362         }
 363 }
 364
 365 int
 366 SettingsCallForwardWaitBarrForm::GetGroupCount(void)
 367 {
 368         return IDI_GROUP_TOTALCOUNT;
 369 }
 370
 371 int
 372 SettingsCallForwardWaitBarrForm::GetItemCount(int groupIndex)
 373 {
 374         int itemCount = 0;
 375         switch (__formType)
 376         {
 377         case FORMTYPE_CALLFORWARDING_TYPE:    //decide voice/video type for forwarding
 378         case FORMTYPE_CALLBARRING_TYPE:    //decide voice/video type for barring
 379         {
 380                 itemCount = CALLTYPE_TOTALCOUNT;
 381         }
 382         break;
 383
 384         case FORMTYPE_VOICE_CALLFORWARDING:     //actual options for call forwarding
 385         {
 386                 itemCount = CALLFORWARD_TOTALITEMCOUNT;
 387         }
 388         break;
 389
 390         case FORMTYPE_VOICE_CALLBARRING:     //actual options for call barring
 391         {
 392                 itemCount = CALLBARRING_TOTALCOUNT;
 393         }
 394         break;
 395
 396         case FORMTYPE_CALL_WAITING:
 397         {
 398                 itemCount = CALLWAITING_TOTALCOUNT;
 399         }
 400         break;
 401
 402         default:
 403                 break;
 404         }
 405         return itemCount;
 406 }
 407
 408 TableViewGroupItem*
 409 SettingsCallForwardWaitBarrForm::CreateGroupItem(int groupIndex, int itemWidth)
 410 {
 411         TableViewGroupItem* pItem = new (std::nothrow) TableViewGroupItem();
 412         pItem->Construct(Dimension(itemWidth, H_LIST_HIDDENGROUP_ITEM));
 413         pItem->SetBackgroundColor(COLOR_GROUP_ITEM_BG);
 414         return pItem;
 415 }
 416
 417 bool
 418 SettingsCallForwardWaitBarrForm::DeleteGroupItem(int groupIndex, TableViewGroupItem* pItem)
 419 {
 420         delete pItem;
 421         pItem = null;
 422         return true;
 423 }
 424
 425 void
 426 SettingsCallForwardWaitBarrForm::UpdateGroupItem(int groupIndex, TableViewGroupItem* pItem)
 427 {
 428         return;
 429 }
 430
 431 TableViewItem*
 432 SettingsCallForwardWaitBarrForm::CreateItem(int groupIndex, int itemIndex, int itemWidth)
 433 {
 434         TableViewItem* pItem = null;
 435         switch (__formType)
 436         {
 437         case FORMTYPE_CALLFORWARDING_TYPE:
 438         case FORMTYPE_CALLBARRING_TYPE:
 439         {
 440                 pItem = CreateSettingCallTypeMenuItem(itemIndex, itemWidth);
 441         }
 442         break;
 443
 444         case FORMTYPE_VOICE_CALLFORWARDING:
 445         {
 446                 pItem = CreateCallForwardingOptions(itemIndex, itemWidth);
 447         }
 448         break;
 449
 450         case FORMTYPE_VOICE_CALLBARRING:
 451         {
 452                 pItem = CreateCallBarringOptions(itemIndex, itemWidth);
 453         }
 454         break;
 455
 456         case FORMTYPE_CALL_WAITING:
 457         {
 458                 pItem = CreateCallWaitingOptions(itemIndex, itemWidth);
 459         }
 460         break;
 461
 462         default:
 463                 break;
 464         }
 465
 466         return pItem;
 467 }
 468
 469 bool
 470 SettingsCallForwardWaitBarrForm::DeleteItem(int groupIndex, int itemIndex, TableViewItem* pItem)
 471 {
 472         delete pItem;
 473         pItem = null;
 474         return true;
 475 }
 476
 477 void
 478 SettingsCallForwardWaitBarrForm::UpdateItem(int groupIndex, int itemIndex, TableViewItem* pItem)
 479 {
 480         if(__formType == FORMTYPE_CALL_WAITING)
 481         {
 482                 Animation* pAnimation = static_cast<Animation*>(pItem->GetControl(IDC_ANIMATION_CONTROL, true));
 483                 if(__isCallWaitingStatusAvailable == false)
 484                 {
 485                         //let the animation play
 486                         if(pAnimation != null)
 487                         {
 488                                 pAnimation->Play();
 489                         }
 490                 }
 491                 else
 492                 {
 493                         //remove animation
 494                         if(pAnimation != null)
 495                         {
 496                                 pAnimation->Stop();
 497                                 pItem->RemoveControl(*pAnimation);
 498                         }
 499                         //show CheckButton with on-off slider style
 500                         CheckButton* pSliderButton = static_cast<CheckButton*>(pItem->GetControl(IDC_SLIDER_CHECHBUTTON,true));
 501                         if(pSliderButton == null)
 502                         {
 503                                 //construct new "CheckButton", if not present
 504                                 int itemWidth = pItem->GetWidth();
 505                                 Rectangle animRect((itemWidth - W_SLIDER_ICON), ((H_LIST_NORMAL_MENU_ITEM - H_SLIDER_ICON) /2), W_SLIDER_ICON, H_SLIDER_ICON);
 506                                 pSliderButton = new (std::nothrow) CheckButton();
 507                                 pSliderButton->Construct(animRect, CHECK_BUTTON_STYLE_ONOFF_SLIDING, BACKGROUND_STYLE_NONE);
 508                                 pSliderButton->SetName(IDC_SLIDER_CHECHBUTTON);
 509                                 pSliderButton->SetActionId(IDA_CALL_WAITING_OPTION_CHECKED, IDA_CALL_WAITING_OPTION_UNCHECKED);
 510                                 pSliderButton->AddActionEventListener(*this);
 511                                 // Add a CheckButton to the Form
 512                                 pItem->AddControl(*pSliderButton);
 513                                 pItem->SetIndividualSelectionEnabled(pSliderButton, false);
 514                         }
 515                         //update status
 516                         pSliderButton->SetSelected(__isCallWaitingEnabled);
 517                 }
 518         }
 519         return;
 520 }
 521
 522 int
 523 SettingsCallForwardWaitBarrForm::GetDefaultGroupItemHeight(void)
 524 {
 525         return H_LIST_HIDDENGROUP_ITEM;
 526 }
 527
 528 int
 529 SettingsCallForwardWaitBarrForm::GetDefaultItemHeight(void)
 530 {
 531         return H_LIST_NORMAL_MENU_ITEM;
 532 }
 533
 534 TableViewItem*
 535 SettingsCallForwardWaitBarrForm::CreateSettingCallTypeMenuItem(int itemIndex, int itemWidth)
 536 {
 537         //text item rectangle
 538         Rectangle itemNameRect(X_LIST_MENU_TEXT_ITEM, 0, (itemWidth - X_LIST_MENU_TEXT_ITEM), H_LIST_NORMAL_MENU_ITEM);
 539         String itemName(L"");
 540         switch (itemIndex)
 541         {
 542         case CALLTYPE_VOICE_CALL:
 543         {
 544                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_CALLTYPE_VOICE_STRING));
 545         }
 546         break;
 547
 548         default:
 549         break;
 550         }
 551
 552         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 553         pItem->Construct(Dimension(itemWidth, H_LIST_NORMAL_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_NORMAL);
 554         //Item Name
 555         Label* pItemLbl = new (std::nothrow) Label();
 556         pItemLbl->Construct(itemNameRect, itemName);
 557         pItemLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 558         pItemLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 559         pItemLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 560         pItemLbl->SetTextColor(COLOR_NORMAL_MAIN_TXT);//COLOR_PRESS_MAIN_TXT
 561         pItem->AddControl(*pItemLbl);
 562         pItem->SetBackgroundColor(COLOR_LIST_MENU_ITEM, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 563
 564         return pItem;
 565 }
 566
 567 void
 568 SettingsCallForwardWaitBarrForm::HandleCallTypeSelected(int itemIndex)
 569 {
 570         SceneManager* pSceneManager = SceneManager::GetInstance();
 571         AppAssert(pSceneManager != null);
 572
 573         switch (itemIndex)
 574         {
 575         case CALLTYPE_VOICE_CALL:
 576         {
 577                 if (__formType == FORMTYPE_CALLFORWARDING_TYPE)
 578                 {
 579                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALL_FORWARD_OPTIONS), null);
 580                 }
 581                 else
 582                 {
 583                         //for FORMTYPE_CALLBARRING_TYPE
 584                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALL_BARRING_OPTIONS), null);
 585                 }
 586         }
 587         break;
 588
 589         default:
 590                 break;
 591         }
 592 }
 593
 594 TableViewItem*
 595 SettingsCallForwardWaitBarrForm::CreateCallForwardingOptions(int itemIndex, int itemWidth)
 596 {
 597         //sub text rectangle
 598         Rectangle subItemRect(X_LIST_MENU_TEXT_ITEM, H_LIST_NORMAL_TXT_ITEM,
 599                                                           (itemWidth - X_LIST_MENU_TEXT_ITEM), H_LIST_SUB_TXT_ITEM);
 600         String subText = AppUtility::GetResourceString(IDS_SETTING_DEACTIVATE_STATUS);
 601
 602         //main text rectangle
 603         Rectangle itemNameRect(X_LIST_MENU_TEXT_ITEM, 0,
 604                                                    (itemWidth - X_LIST_MENU_TEXT_ITEM), H_LIST_NORMAL_TXT_ITEM);
 605         String itemName;
 606         switch (itemIndex)
 607         {
 608         case CALLFORWARD_ALWAYS:
 609         {
 610                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEFORWARD_ALWAYS));
 611         }
 612         break;
 613
 614         case CALLFORWARD_IF_BUSY:
 615         {
 616                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEFORWARD_IFBUSY));
 617         }
 618         break;
 619
 620         case CALLFORWARD_IF_NO_REPLY:
 621         {
 622                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEFORWARD_NOREPLY));
 623         }
 624         break;
 625
 626         case CALLFORWARD_IF_OUT_OF_REACH:
 627         {
 628                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEFORWARD_OUTOFREACH));
 629         }
 630         break;
 631
 632         default:
 633                 break;
 634         }
 635
 636         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 637         pItem->Construct(Dimension(itemWidth, H_LIST_NORMAL_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING);
 638
 639         //main text item
 640         Label* pItemLbl = new (std::nothrow) Label();
 641         pItemLbl->Construct(itemNameRect, itemName);
 642         pItemLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 643         pItemLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 644         pItemLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 645         pItemLbl->SetTextColor(COLOR_MAIN_TXT);
 646         pItem->AddControl(*pItemLbl);
 647         //sub text item
 648         Label* pSubTxtLbl = new (std::nothrow) Label();
 649         pSubTxtLbl->Construct(subItemRect, subText);
 650         pSubTxtLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 651         pSubTxtLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 652         pSubTxtLbl->SetTextConfig(FONT_SIZE_SUB_TXT, LABEL_TEXT_STYLE_NORMAL);
 653         pSubTxtLbl->SetTextColor(COLOR_NORMAL_SUB_TXT);
 654         pItem->AddControl(*pSubTxtLbl);
 655
 656         pItem->SetBackgroundColor(COLOR_LIST_MENU_ITEM, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 657         return pItem;
 658 }
 659
 660 void
 661 SettingsCallForwardWaitBarrForm::HandleCallForwardingOptionSelected(int itemIndex, TableViewItemStatus status)
 662 {
 663         if(status == TABLE_VIEW_ITEM_STATUS_CHECKED || status == TABLE_VIEW_ITEM_STATUS_SELECTED)
 664         {
 665                 //Do not activate any other call forwarding option, if 'CALLFORWARD_ALWAYS' is selected.
 666                 if((itemIndex != CALLFORWARD_ALWAYS) && (__isCallForwardAlwaysActivated == true))
 667                 {
 668                         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 669                         pMainMenuTableView->SetItemChecked(CALLFORWARDING_GROUP, itemIndex, false);
 670                         pMainMenuTableView->Invalidate(true);
 671                         return;
 672                 }
 673
 674                 SceneManager* pSceneManager = SceneManager::GetInstance();
 675                 AppAssert(pSceneManager != null);
 676
 677                 ArrayList* pArgs = new (std::nothrow) ArrayList(SingleObjectDeleter);
 678                 pArgs->Construct(1);
 679                 Integer* indexInt = new (std::nothrow) Integer(itemIndex);
 680                 pArgs->Add(indexInt);
 681
 682                 switch (itemIndex)
 683                 {
 684                 case CALLFORWARD_IF_NO_REPLY:
 685                 {
 686                         //switch to "NOREPLY_ForwardToNumber" form
 687                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_NOREPLY_FORWARD_TO_NUMBER), pArgs);
 688                 }
 689                 break;
 690
 691                 default:
 692                 {
 693                         //switch to "ForwardToNumber" form
 694                         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_FORWARD_TO_NUMBER), pArgs);
 695                 }
 696                 break;
 697                 }
 698         }
 699         else
 700         {
 701                 __pSettingsPresentor->SetCallForwardStatus(String(L""),CallForwardCondition(itemIndex), false, 0);
 702         }
 703 }
 704
 705 TableViewItem*
 706 SettingsCallForwardWaitBarrForm::CreateCallBarringOptions(int itemIndex, int itemWidth)
 707 {
 708         //text item rectangle
 709         Rectangle itemNameRect(X_LIST_MENU_TEXT_ITEM, 0, (itemWidth - X_LIST_MENU_TEXT_ITEM), H_LIST_NORMAL_MENU_ITEM);
 710
 711         String itemName(L"");
 712         switch (itemIndex)
 713         {
 714         case CALLBARRING_ALL_OUTGOING_CALL:
 715         {
 716                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_OUTGOING));
 717         }
 718         break;
 719
 720         case CALLBARRING_INTERNATIONAL_CALL:
 721         {
 722                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_INTERNATIONAL));
 723         }
 724         break;
 725
 726         case CALLBARRING_INTERNATIONAL_EXCEPT_HOME:
 727         {
 728                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_EXCEPTHOME));
 729         }
 730         break;
 731
 732         case CALLBARRING_ALL_INCOMING_CALL:
 733         {
 734                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_INCOMING));
 735         }
 736         break;
 737
 738         case CALLBARRING_INCOMING_WHILE_ROAMING:
 739         {
 740                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_VOICEBARRING_WHENROAMING));
 741         }
 742         break;
 743
 744         default:
 745                 break;
 746         }
 747
 748         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 749         pItem->Construct(Dimension(itemWidth, H_LIST_NORMAL_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING);
 750         //Item Name
 751         Label* pItemLbl = new (std::nothrow) Label();
 752         pItemLbl->Construct(itemNameRect, itemName);
 753         pItemLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 754         pItemLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 755         pItemLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 756         pItemLbl->SetTextColor(COLOR_MAIN_TXT);
 757         pItem->AddControl(*pItemLbl);
 758
 759         pItem->SetBackgroundColor(COLOR_LIST_MENU_ITEM, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 760         return pItem;
 761 }
 762
 763 void
 764 SettingsCallForwardWaitBarrForm::HandleCallBarringOptionSelected(int itemIndex, TableViewItemStatus status)
 765 {
 766         //Don't change the item status and goto next form.
 767         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 768         if(status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 769         {
 770                 pMainMenuTableView->SetItemChecked(0,itemIndex,false);
 771         }
 772         else if(status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 773         {
 774                 pMainMenuTableView->SetItemChecked(0,itemIndex,true);
 775         }
 776
 777         //Whether status is checked or unchecked, always goto BarringPwdForm form
 778         //to take password from user. Activation / De-activation of barring happens from BarringPwdForm.
 779         SceneManager* pSceneManager = SceneManager::GetInstance();
 780         AppAssert(pSceneManager != null);
 781
 782         ArrayList* pArgs = new (std::nothrow) ArrayList(SingleObjectDeleter);
 783         pArgs->Construct(2);
 784         Integer* indexInt = new (std::nothrow) Integer(itemIndex);
 785         pArgs->Add(indexInt);
 786         Integer* itemState = new (std::nothrow) Integer(status);
 787         pArgs->Add(itemState);
 788         pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_SET_BARRING_PWD), pArgs);
 789 }
 790
 791 TableViewItem*
 792 SettingsCallForwardWaitBarrForm::CreateCallWaitingOptions(int itemIndex, int itemWidth)
 793 {
 794         //text item rectangle
 795         Rectangle itemNameRect(X_LIST_MENU_TEXT_ITEM, 0,
 796                         (itemWidth - X_LIST_MENU_TEXT_ITEM - X_LIST_MENU_TEXT_ITEM - W_EXPAND_ICON), H_LIST_NORMAL_MENU_ITEM);
 797         String itemName(L"");
 798         switch (itemIndex)
 799         {
 800         case CALLWAITING_ITEM:
 801         {
 802                 itemName.Append(AppUtility::GetResourceString(IDS_SETTING_CALL_WAITING_OPTIONS));
 803         }
 804         break;
 805
 806         default:
 807         break;
 808         }
 809
 810         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 811         pItem->Construct(Dimension(itemWidth, H_LIST_NORMAL_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_NORMAL);
 812
 813         //Item Name
 814         Label* pItemLbl = new (std::nothrow) Label();
 815         pItemLbl->Construct(itemNameRect, itemName);
 816         pItemLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 817         pItemLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 818         pItemLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 819         pItemLbl->SetTextColor(COLOR_MAIN_TXT);
 820         pItem->AddControl(*pItemLbl);
 821
 822         //animation icon
 823         if(__pAnimationFrameList != null && __pAnimationFrameList->GetCount() > 0)
 824         {
 825                 Rectangle animRect((itemNameRect.x + itemNameRect.width), ((H_LIST_NORMAL_MENU_ITEM - H_EXPAND_ICON) /2), W_EXPAND_ICON, H_EXPAND_ICON);
 826                 Animation* pAnimation = new (std::nothrow) Animation();
 827                 pAnimation->Construct(animRect, *__pAnimationFrameList);
 828                 pAnimation->SetName(IDC_ANIMATION_CONTROL);
 829                 pAnimation->SetRepeatCount(IDI_ANIM_DURATION * IDI_ANIM_PROGRESS_COUNT * IDI_ANIM_PROGRESS_COUNT);
 830                 pItem->AddControl(*pAnimation);
 831         }
 832
 833         //set background
 834         pItem->SetBackgroundColor(COLOR_LIST_MENU_ITEM, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 835         return pItem;
 836 }
 837
 838 void
 839 SettingsCallForwardWaitBarrForm::HandleCallWaitingOptionSelected(TableViewItem* pItem, int itemIndex, TableViewItemStatus status)
 840 {
 841         switch (itemIndex)
 842         {
 843         case CALLWAITING_ITEM:
 844         {
 845                 //set the state based on response
 846                 CheckButton* pSliderButton = static_cast<CheckButton*>(pItem->GetControl(IDC_SLIDER_CHECHBUTTON,true));
 847                 if(pSliderButton != null)
 848                 {
 849                         bool activateWaiting = !(pSliderButton->IsSelected());
 850                         int errorCode = __pSettingsPresentor->SetCallWaitingStatus(activateWaiting);
 851                         if(errorCode != ERROR_NONE)
 852                         {
 853                                 ShowErrorMessage(errorCode);
 854                         }
 855                 }
 856         }
 857         break;
 858
 859         default:
 860                 break;
 861         }
 862 }
 863
 864 //
 865 void
 866 SettingsCallForwardWaitBarrForm::HandleGetCallWaitingResponse(bool isCallSuccessful, bool callWaitingActivated)
 867 {
 868         if (__formType == FORMTYPE_CALL_WAITING)
 869         {
 870                 __isCallWaitingStatusAvailable = true;
 871                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 872                 //Hide animation and add on/Off checkbox by modifying item
 873                 __isCallWaitingEnabled = callWaitingActivated;
 874                 pMainMenuTableView->RefreshItem(0, CALLWAITING_ITEM, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 875         }
 876 }
 877
 878 void
 879 SettingsCallForwardWaitBarrForm::HandleSetCallWaitingResponse(bool isCallSuccessful, bool isCallWaitingEnabled)
 880 {
 881         if (__formType == FORMTYPE_CALL_WAITING)
 882         {
 883                 __isCallWaitingStatusAvailable = true;
 884                 //Update status of "On/Off" slider button
 885                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 886                 __isCallWaitingEnabled = isCallWaitingEnabled;
 887                 pMainMenuTableView->RefreshItem(0, CALLWAITING_ITEM, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 888         }
 889 }
 890
 891 void
 892 SettingsCallForwardWaitBarrForm::HandleGetCallForwardResponse(bool isCallSuccessful, CallForwardCondition callFwdCondition, const String& callFwdNumber, bool callForwardActivated, int noReplyWaitTime)
 893 {
 894         if (__formType == FORMTYPE_VOICE_CALLFORWARDING)
 895         {
 896                 //todo: grey out the item if call is unsuccessful
 897                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 898
 899                 //todo: set subtext for the item
 900                 switch (callFwdCondition)
 901                 {
 902                 case CALL_FORWARD_ALL:
 903                 {
 904                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_ALWAYS, callForwardActivated);
 905                         __isCallForwardAlwaysActivated = callForwardActivated;
 906                 }
 907                 break;
 908
 909                 case CALL_FORWARD_BUSY:
 910                 {
 911                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_BUSY, callForwardActivated);
 912                 }
 913                 break;
 914
 915                 case CALL_FORWARD_NO_REPLY:
 916                 {
 917                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_NO_REPLY, callForwardActivated);
 918                 }
 919                 break;
 920
 921                 case CALL_FORWARD_NOT_REACHABLE:
 922                 {
 923                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_OUT_OF_REACH, callForwardActivated);
 924                 }
 925                 break;
 926
 927                 default:
 928                         break;
 929                 }
 930                 pMainMenuTableView->Invalidate(true);
 931         }
 932 }
 933
 934 void
 935 SettingsCallForwardWaitBarrForm::HandleSetCallForwardResponse(bool isCallSuccessful, CallForwardCondition callFwdCondition, const String& callFwdNumber, bool isCallForwardActivated, int noReplyWaitTime)
 936 {
 937         if (__formType == FORMTYPE_VOICE_CALLFORWARDING)
 938         {
 939                 //todo: grey out the item if call is unsuccessful
 940                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 941                 //todo: set the number as the subtext for the item
 942                 switch (callFwdCondition)
 943                 {
 944                 case CALL_FORWARD_ALL:
 945                 {
 946                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_ALWAYS, isCallForwardActivated);
 947                         __isCallForwardAlwaysActivated = isCallForwardActivated;
 948                 }
 949                 break;
 950
 951                 case CALL_FORWARD_BUSY:
 952                 {
 953                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_BUSY, isCallForwardActivated);
 954                 }
 955                 break;
 956
 957                 case CALL_FORWARD_NO_REPLY:
 958                 {
 959                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_NO_REPLY, isCallForwardActivated);
 960                 }
 961                 break;
 962
 963                 case CALL_FORWARD_NOT_REACHABLE:
 964                 {
 965                         pMainMenuTableView->SetItemChecked(0, CALLFORWARD_IF_OUT_OF_REACH, isCallForwardActivated);
 966                 }
 967                 break;
 968
 969                 default:
 970                         break;
 971                 }
 972                 pMainMenuTableView->Invalidate(true);
 973         }
 974 }
 975
 976 void
 977 SettingsCallForwardWaitBarrForm::HandleSetCallBarringResponse(bool isCallSuccessful, CallBarringType callBarringType, bool isBarringActivated)
 978 {
 979         if (__formType == FORMTYPE_VOICE_CALLBARRING)
 980         {
 981                 //todo: grey out the item if call is unsuccessful
 982                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 983                 switch (callBarringType)
 984                 {
 985                 case CALL_BARRING_ALL_OUTGOING:
 986                 {
 987                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_ALL_OUTGOING_CALL, isBarringActivated);
 988                 }
 989                 break;
 990
 991                 case CALL_BARRING_INTERNATIONAL_OUTGOING:
 992                 {
 993                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INTERNATIONAL_CALL, isBarringActivated);
 994                 }
 995                 break;
 996
 997                 case CALL_BARRING_INTERNATIONAL_EXCEPT_HOME:
 998                 {
 999                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INTERNATIONAL_EXCEPT_HOME, isBarringActivated);
1000                 }
1001                 break;
1002
1003                 case CALL_BARRING_ALL_INCOMING:
1004                 {
1005                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_ALL_INCOMING_CALL, isBarringActivated);
1006                 }
1007                 break;
1008
1009                 case CALL_BARRING_INCOMING_ROAMING:
1010                 {
1011                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INCOMING_WHILE_ROAMING, isBarringActivated);
1012                 }
1013                 break;
1014
1015                 default:
1016                         break;
1017                 }
1018                 pMainMenuTableView->Invalidate(true);
1019         }
1020 }
1021 void
1022 SettingsCallForwardWaitBarrForm::HandleGetCallBarringResponse(bool isCallSuccessful, CallBarringType callBarringType, bool isBarringActivated)
1023 {
1024         if (__formType == FORMTYPE_VOICE_CALLBARRING)
1025         {
1026                 //todo: grey out the item if call is unsuccessful
1027                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
1028                 switch (callBarringType)
1029                 {
1030                 case CALL_BARRING_ALL_OUTGOING:
1031                 {
1032                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_ALL_OUTGOING_CALL, isBarringActivated);
1033                 }
1034                 break;
1035
1036                 case CALL_BARRING_INTERNATIONAL_OUTGOING:
1037                 {
1038                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INTERNATIONAL_CALL, isBarringActivated);
1039                 }
1040                 break;
1041
1042                 case CALL_BARRING_INTERNATIONAL_EXCEPT_HOME:
1043                 {
1044                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INTERNATIONAL_EXCEPT_HOME, isBarringActivated);
1045                 }
1046                 break;
1047
1048                 case CALL_BARRING_ALL_INCOMING:
1049                 {
1050                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_ALL_INCOMING_CALL, isBarringActivated);
1051                 }
1052                 break;
1053
1054                 case CALL_BARRING_INCOMING_ROAMING:
1055                 {
1056                         pMainMenuTableView->SetItemChecked(0, CALLBARRING_INCOMING_WHILE_ROAMING, isBarringActivated);
1057                 }
1058                 break;
1059
1060                 default:
1061                         break;
1062                 }
1063                 pMainMenuTableView->Invalidate(true);
1064         }
1065 }
1066
1067 void
1068 SettingsCallForwardWaitBarrForm::UncheckAllOptions(void)
1069 {
1070         //un-check all items
1071         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
1072         if(pMainMenuTableView != null)
1073         {
1074                 switch(__formType)
1075                 {
1076                 case FORMTYPE_VOICE_CALLFORWARDING:
1077                 {
1078                         for (int itemIndex = CALLFORWARD_ALWAYS; itemIndex < CALLFORWARD_TOTALITEMCOUNT; itemIndex++)
1079                         {
1080                                 pMainMenuTableView->SetItemChecked(0, itemIndex, false);
1081                         }
1082                 }
1083                 break;
1084
1085                 case FORMTYPE_VOICE_CALLBARRING:
1086                 {
1087                         for (int itemIndex = CALLBARRING_ALL_OUTGOING_CALL; itemIndex < CALLBARRING_TOTALCOUNT; itemIndex++)
1088                         {
1089                                 pMainMenuTableView->SetItemChecked(0, itemIndex, false);
1090                         }
1091                 }
1092                 break;
1093
1094                 case FORMTYPE_CALL_WAITING:
1095                 {
1096                         __isCallWaitingStatusAvailable = true;
1097                         __isCallWaitingEnabled = false;
1098                         pMainMenuTableView->RefreshItem(0, CALLWAITING_ITEM, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
1099                 }
1100                 break;
1101
1102                 default:
1103                         break;
1104                 }
1105                 pMainMenuTableView->Invalidate(true);
1106         }
1107 }
1108
1109 void
1110 SettingsCallForwardWaitBarrForm::ShowErrorMessage(int errorCode)
1111 {
1112         //show error msg Popup
1113         if (__pErrorMsgPopup == null)
1114         {
1115                 __pErrorMsgPopup = new (std::nothrow) ErrorMsgPopup(this);
1116         }
1117         __pErrorMsgPopup->ShowErrorMsgPopupN(errorCode);
1118 }
1119
1120 void
1121 SettingsCallForwardWaitBarrForm::HandlePopupClosed(void)
1122 {
1123         Draw();
1124         delete __pErrorMsgPopup;
1125         __pErrorMsgPopup = null;
1126         return;
1127 }