src/PhnSettingsForwardToNumberForm.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    PhnSettingsForwardToNumberForm.cpp
  19  * @brief   Setting Forward to number form
  20  */
  21 #include <FApp.h>
  22 #include <FBase.h>
  23 #include "PhnAppUtility.h"
  24 #include "PhnCallPresentationModel.h"
  25 #include "PhnSettingsConstants.h"
  26 #include "PhnSettingsPresentationModel.h"
  27 #include "PhnSettingsForwardToNumberForm.h"
  28 #include "PhnSceneRegister.h"
  29 #include "PhnTypes.h"
  30
  31 using namespace Tizen::App;
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Graphics;
  35 using namespace Tizen::Ui;
  36 using namespace Tizen::Ui::Controls;
  37 using namespace Tizen::Ui::Scenes;
  38
  39 static const wchar_t* IDL_SETTINGS_NOREPLY_FORWARDTO_NUMBER_FORM = L"IDL_SETTINGS_NOREPLY_FORWARDTO_NUMBER_FORM";
  40 static const wchar_t* IDL_SETTINGS_FORWARDTO_NUMBER_FORM = L"IDL_SETTINGS_FORWARDTO_NUMBER_FORM";
  41 const int IDI_WAITTIMEOPTIONS_TOTALCOUNT = 6;
  42
  43 SettingsForwardToNumberForm::SettingsForwardToNumberForm(ForwardCondition forwardCondition)
  44         : __forwardCondition(forwardCondition)
  45         , __pSettingsPresentor(null)
  46         , __selectedWaitTime(WAITTIMEOPTIONS_THIRTY_SEC)
  47         , __isWaitTimeOptionsMenuExpanded(false)
  48         , __pErrorMsgPopup(null)
  49 {
  50 }
  51
  52 SettingsForwardToNumberForm::~SettingsForwardToNumberForm(void)
  53 {
  54 }
  55
  56 bool
  57 SettingsForwardToNumberForm::Initialize(void)
  58 {
  59         switch (__forwardCondition)
  60         {
  61         case FORWARDCONDITION_NOREPLY:
  62         {
  63                 Construct(IDL_SETTINGS_NOREPLY_FORWARDTO_NUMBER_FORM);
  64         }
  65         break;
  66
  67         default:
  68         {
  69                 Construct(IDL_SETTINGS_FORWARDTO_NUMBER_FORM);
  70         }
  71         break;
  72         }
  73
  74         return true;
  75 }
  76
  77 result
  78 SettingsForwardToNumberForm::OnInitializing(void)
  79 {
  80         result r = E_SUCCESS;
  81         //Initialize Header
  82         InitializeHeader();
  83         //Initialize list view
  84         r = InitializeGroupedTableView();
  85         TryReturn(r == E_SUCCESS,r,"GroupedTableView initialization failed");
  86         //Initialize numeric edit field
  87         InitializeNumberEditField();
  88         return r;
  89 }
  90
  91 void
  92 SettingsForwardToNumberForm::InitializeHeader(void)
  93 {
  94         Header* pHeader = GetHeader();
  95         if (pHeader != null)
  96         {
  97                 pHeader->SetStyle(HEADER_STYLE_BUTTON);
  98                 //'Done' item
  99                 String doneItemName;
 100                 doneItemName.Append(AppUtility::GetResourceString(IDS_SETTING_DONE_HEADER_ITEM));
 101                 HeaderItem doneHeaderItem;
 102                 doneHeaderItem.Construct(IDA_SAVE_HEADER_ITEMID);
 103                 doneHeaderItem.SetText(doneItemName);
 104                 pHeader->AddItem(doneHeaderItem);
 105                 pHeader->SetItemEnabled(0, false);
 106
 107                 //'Cancel' item
 108                 ButtonItem cancelHeaderItem;
 109                 cancelHeaderItem.Construct(BUTTON_ITEM_STYLE_ICON, IDA_CANCEL_HEADER_ITEMID);
 110                 Bitmap* pNormalBmp = AppUtility::GetBitmapFromResourcesN(IDB_CANCEL_FOOTER_ITEM, W_HDR_FTR_ICON, H_HDR_FTR_ICON);
 111                 cancelHeaderItem.SetIcon(BUTTON_ITEM_STATUS_NORMAL, pNormalBmp);
 112                 cancelHeaderItem.SetIcon(BUTTON_ITEM_STATUS_PRESSED, pNormalBmp);
 113                 pHeader->SetButton(BUTTON_POSITION_RIGHT, cancelHeaderItem);
 114                 delete pNormalBmp;
 115                 pNormalBmp = null;
 116
 117                 pHeader->AddActionEventListener(*this);
 118         }
 119 }
 120
 121 result
 122 SettingsForwardToNumberForm::OnTerminating(void)
 123 {
 124         result r = E_SUCCESS;
 125         return r;
 126 }
 127
 128 void
 129 SettingsForwardToNumberForm::OnActionPerformed(const Control& source, int actionId)
 130 {
 131         SceneManager* pSceneManager = SceneManager::GetInstance();
 132         AppAssert(pSceneManager != null);
 133
 134         switch (actionId)
 135         {
 136         case IDA_CANCEL_HEADER_ITEMID:
 137         {
 138                 //go back to previous form
 139                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALL_FORWARD_OPTIONS), null);
 140         }
 141         break;
 142
 143         case IDA_SAVE_HEADER_ITEMID:
 144         {
 145                 EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 146                 if (pEditFieldNumber != null)
 147                 {
 148                         //disable all other forwarding conditions, if 'CALL_FORWARD_ALL' is activated
 149                         /*if(__callForwardCondition == CALL_FORWARD_ALL)
 150                         {
 151                                 __pSettingsPresentor->SetCallForwardStatus(L"", CALL_FORWARD_BUSY, false, 0);
 152                                 __pSettingsPresentor->SetCallForwardStatus(L"", CALL_FORWARD_NO_REPLY, false, 0);
 153                                 __pSettingsPresentor->SetCallForwardStatus(L"", CALL_FORWARD_NOT_REACHABLE, false, 0);
 154                         }*/
 155
 156                         //enable status
 157                         String phoneNumber = pEditFieldNumber->GetText();
 158                         int errorCode = __pSettingsPresentor->SetCallForwardStatus(phoneNumber, __callForwardCondition, true, __selectedWaitTime);
 159                         if(errorCode != ERROR_NONE)
 160                         {
 161                                 ShowErrorMessage(errorCode);
 162                                 return;
 163                         }
 164                 }
 165                 //go back to previous form
 166                 pSceneManager->GoForward(ForwardSceneTransition(IDSCN_SCENE_CALL_FORWARD_OPTIONS), null);
 167         }
 168         break;
 169
 170         case IDA_VOICEMAIL:
 171         {
 172         }
 173         break;
 174
 175         case IDA_SELECT_CONTACT:
 176         {
 177                 LaunchContactsAppControl();
 178         }
 179         break;
 180
 181         default:
 182                 break;
 183         }
 184 }
 185
 186 void
 187 SettingsForwardToNumberForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 188 {
 189         __pSettingsPresentor = SettingsPresentationModel::GetInstance();
 190         __pSettingsPresentor->AddSettingEventListener(this);
 191
 192         if (pArgs != null)
 193         {
 194                 int errorCode = ERROR_NONE;
 195                 Integer* indexInt = static_cast<Integer*>(pArgs->GetAt(0));
 196                 switch (indexInt->ToInt())
 197                 {
 198                 case 0:
 199                 {
 200                         __callForwardCondition = CALL_FORWARD_ALL;
 201                 }
 202                 break;
 203
 204                 case 1:
 205                 {
 206                         __callForwardCondition = CALL_FORWARD_BUSY;
 207                 }
 208                 break;
 209
 210                 case 2:
 211                 {
 212                         __callForwardCondition = CALL_FORWARD_NO_REPLY;
 213                 }
 214                 break;
 215
 216                 case 3:
 217                 {
 218                         __callForwardCondition = CALL_FORWARD_NO_REPLY;
 219                 }
 220                 break;
 221
 222                 default:
 223                         break;
 224                 }
 225
 226                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 227                 if(pMainMenuTableView != null)
 228                 {
 229                         __selectedWaitTime = WAITTIMEOPTIONS_THIRTY_SEC;
 230                         int selectIndex = (__selectedWaitTime / 5) - 1;
 231                         //by default, "30 seconds" option is selected
 232                         pMainMenuTableView->SetItemChecked(GROUP_WAIT_TIME_OPTIONS, selectIndex, true);
 233                         //uncheck all other items
 234                         for (int deselectIndex = 0; deselectIndex < selectIndex; deselectIndex++)
 235                         {
 236                                 pMainMenuTableView->SetItemChecked(GROUP_WAIT_TIME_OPTIONS, deselectIndex, false);
 237                         }
 238                         pMainMenuTableView->RefreshItem(GROUP_SELECT_WAIT_TIME, SELECTWAITTIME_WAIT_TIME, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 239                         pMainMenuTableView->Invalidate(true);
 240                 }
 241
 242                 //fetch forwarding status
 243                 errorCode = __pSettingsPresentor->GetCallForwardStatus(__callForwardCondition);
 244                 if(errorCode != ERROR_NONE)
 245                 {
 246                         //Show error message popup
 247                         ShowErrorMessage(errorCode);
 248                 }
 249
 250                 //clear text field and disable "Done" button
 251                 EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 252                 if(pEditFieldNumber != null)
 253                 {
 254                         pEditFieldNumber->Clear();
 255                         pEditFieldNumber->SetFocus();
 256                 }
 257                 Header* pHeader = GetHeader();
 258                 if (pHeader != null)
 259                 {
 260                         pHeader->SetItemEnabled(0, false);
 261                 }
 262
 263                 pArgs->RemoveAll();
 264                 delete pArgs;
 265                 pArgs = null;
 266         }
 267 }
 268
 269 void
 270 SettingsForwardToNumberForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 271 {
 272         __pSettingsPresentor->RemoveSettingEventListener();
 273         EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 274         if (pEditFieldNumber != null)
 275         {
 276                 pEditFieldNumber->HideKeypad();
 277         }
 278 }
 279
 280 void
 281 SettingsForwardToNumberForm::InitializeNumberEditField(void)
 282 {
 283         EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 284         if (pEditFieldNumber != null)
 285         {
 286                 pEditFieldNumber->AddKeypadEventListener(*this);
 287                 pEditFieldNumber->AddTextEventListener(*this);
 288                 pEditFieldNumber->SetOverlayKeypadCommandButtonVisible(false);
 289         }
 290
 291         Button* pContactBtn = static_cast<Button*>(GetControl(IDC_SELECT_CONTACT_BUTTON));
 292         if (pContactBtn != null)
 293         {
 294                 pContactBtn->SetActionId(IDA_SELECT_CONTACT);
 295                 pContactBtn->AddActionEventListener(*this);
 296         }
 297
 298         Button* pVoiceMailBtn = static_cast<Button*>(GetControl(IDC_VOICEMAIL_BUTTON));
 299         if (pVoiceMailBtn != null)
 300         {
 301                 pVoiceMailBtn->SetActionId(IDA_VOICEMAIL);
 302                 pVoiceMailBtn->AddActionEventListener(*this);
 303         }
 304 }
 305
 306 result
 307 SettingsForwardToNumberForm::InitializeGroupedTableView(void)
 308 {
 309         result r = E_SUCCESS;
 310         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 311         if (pMainMenuTableView != null)
 312         {
 313                 pMainMenuTableView->SetGroupedLookEnabled(true);
 314                 pMainMenuTableView->SetItemProvider(this);
 315                 r = pMainMenuTableView->AddGroupedTableViewItemEventListener(*this);
 316                 pMainMenuTableView->UpdateTableView();
 317                 CollapseSelectiveGroups(pMainMenuTableView);
 318         }
 319         return r;
 320 }
 321
 322 void
 323 SettingsForwardToNumberForm::CollapseSelectiveGroups(GroupedTableView* pMainMenuTableView)
 324 {
 325         //This function should be called only from "InitializeGroupedTableView()".
 326         //since collapsing individual groups while GroupTableView construction causes flicker.
 327         pMainMenuTableView->CollapseAllGroup();
 328         //Expand other groups
 329         pMainMenuTableView->ExpandGroup(GROUP_SELECT_WAIT_TIME);
 330         pMainMenuTableView->UpdateTableView();
 331 }
 332
 333 void
 334 SettingsForwardToNumberForm::OnGroupedTableViewItemStateChanged(GroupedTableView& tableView, int groupIndex, int itemIndex, TableViewItem* pItem, TableViewItemStatus status)
 335 {
 336         switch (groupIndex)
 337         {
 338         case GROUP_SELECT_WAIT_TIME:
 339         {
 340                 //close overlay keypad
 341                 EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 342                 if (pEditFieldNumber != null && pEditFieldNumber->HasFocus() == true)
 343                 {
 344                         //If Keyapd is open, then "CloseGroup" in OnKeypadClose() callback
 345                         pEditFieldNumber->HideKeypad();
 346                 }
 347                 else
 348                 {
 349                         //keypad is closed, directly expand group
 350                         ToggleGroupExpansion(tableView, itemIndex);
 351                 }
 352         }
 353         break;
 354
 355         case GROUP_WAIT_TIME_OPTIONS:
 356         {
 357                 HandleSelectedWaitingTime(tableView, itemIndex, status);
 358         }
 359         break;
 360
 361         default:
 362                 break;
 363         }
 364 }
 365
 366 int
 367 SettingsForwardToNumberForm::GetGroupCount(void)
 368 {
 369         return GROUP_TOTALCOUNT;
 370 }
 371
 372 int
 373 SettingsForwardToNumberForm::GetItemCount(int groupIndex)
 374 {
 375         int itemCount = 0;
 376         switch (groupIndex)
 377         {
 378         case GROUP_SELECT_WAIT_TIME:
 379         {
 380                 itemCount = SELECTWAITTIME_TOTALCOUNT;
 381         }
 382         break;
 383
 384         case GROUP_WAIT_TIME_OPTIONS:
 385         {
 386                 itemCount = IDI_WAITTIMEOPTIONS_TOTALCOUNT;
 387         }
 388         break;
 389
 390         default:
 391                 break;
 392         }
 393         return itemCount;
 394 }
 395
 396 TableViewGroupItem*
 397 SettingsForwardToNumberForm::CreateGroupItem(int groupIndex, int itemWidth)
 398 {
 399         TableViewGroupItem* pItem = new (std::nothrow) TableViewGroupItem();
 400         pItem->Construct(Dimension(itemWidth, H_LIST_HIDDENGROUP_ITEM));
 401         pItem->SetBackgroundColor(COLOR_GROUP_ITEM_BG, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 402         return pItem;
 403 }
 404
 405 bool
 406 SettingsForwardToNumberForm::DeleteGroupItem(int groupIndex, TableViewGroupItem* pItem)
 407 {
 408         delete pItem;
 409         pItem = null;
 410         return true;
 411 }
 412
 413 void
 414 SettingsForwardToNumberForm::UpdateGroupItem(int groupIndex, TableViewGroupItem* pItem)
 415 {
 416         return;
 417 }
 418
 419 TableViewItem*
 420 SettingsForwardToNumberForm::CreateItem(int groupIndex, int itemIndex, int itemWidth)
 421 {
 422         TableViewItem* pItem = null;
 423
 424         switch (groupIndex)
 425         {
 426         case GROUP_SELECT_WAIT_TIME:
 427         {
 428                 pItem = CreateExpandableWaitingItem(itemWidth);
 429         }
 430         break;
 431
 432         case GROUP_WAIT_TIME_OPTIONS:
 433         {
 434                 pItem = CreateWaitingTimeOptionsMenuItems(itemIndex, itemWidth);
 435         }
 436         break;
 437
 438         default:
 439         break;
 440         }
 441
 442         return pItem;
 443 }
 444
 445 bool
 446 SettingsForwardToNumberForm::DeleteItem(int groupIndex, int itemIndex, TableViewItem* pItem)
 447 {
 448         delete pItem;
 449         pItem = null;
 450         return true;
 451 }
 452
 453 void
 454 SettingsForwardToNumberForm::UpdateItem(int groupIndex, int itemIndex, Tizen::Ui::Controls::TableViewItem* pItem)
 455 {
 456         if(groupIndex == GROUP_SELECT_WAIT_TIME && itemIndex == SELECTWAITTIME_WAIT_TIME)
 457         {
 458                 String subText = FetchTextForSelectedOption(__selectedWaitTime);
 459                 //sub text item
 460                 Label* pSubTxtLbl = static_cast<Label*>(pItem->GetControl(IDC_SELECTEDOPTION_SUBTEXT_LABEL, true));
 461                 if(pSubTxtLbl != null)
 462                 {
 463                         pSubTxtLbl->SetText(subText);
 464                         pSubTxtLbl->Invalidate(true);
 465                 }
 466                 //set Drop-down icon to item
 467                 SetExpandIconToItem(pItem, __isWaitTimeOptionsMenuExpanded);
 468         }
 469 }
 470
 471 int
 472 SettingsForwardToNumberForm::GetDefaultGroupItemHeight(void)
 473 {
 474         return H_LIST_HIDDENGROUP_ITEM;
 475 }
 476
 477 int
 478 SettingsForwardToNumberForm::GetDefaultItemHeight(void)
 479 {
 480         return H_LIST_NORMAL_MENU_ITEM;
 481 }
 482
 483 TableViewItem*
 484 SettingsForwardToNumberForm::CreateExpandableWaitingItem(int itemWidth)
 485 {
 486         //main text
 487         Rectangle mainItemRect(X_LIST_MENU_TEXT_ITEM, Y_LIST_MENU_TEXT_ITEM, (itemWidth - (2 * X_LIST_MENU_TEXT_ITEM) - W_EXPAND_ICON),
 488                                                            H_LIST_DROPDOWN_TXT_ITEM);
 489         String mainText = AppUtility::GetResourceString(IDS_SETTING_WAITING_TIME_STRING);
 490         //sub text
 491         Rectangle subItemRect(X_LIST_MENU_TEXT_ITEM, (Y_LIST_MENU_TEXT_ITEM + H_LIST_DROPDOWN_TXT_ITEM),
 492                                                           (itemWidth - (2 * X_LIST_MENU_TEXT_ITEM) - W_EXPAND_ICON), H_LIST_DROPDOWN_TXT_ITEM);
 493         String subText = FetchTextForSelectedOption(__selectedWaitTime);
 494
 495         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 496         pItem->Construct(Dimension(itemWidth, H_LIST_DROPDOWN_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_NORMAL);
 497
 498         //main text item
 499         Label* pMainTxtLbl = new (std::nothrow) Label();
 500         pMainTxtLbl->Construct(mainItemRect, mainText);
 501         pMainTxtLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 502         pMainTxtLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 503         pMainTxtLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 504         pMainTxtLbl->SetTextColor(COLOR_NORMAL_MAIN_TXT);
 505         pItem->AddControl(*pMainTxtLbl);
 506         //sub text item
 507         Label* pSubTxtLbl = new (std::nothrow) Label();
 508         pSubTxtLbl->Construct(subItemRect, subText);
 509         pSubTxtLbl->SetName(IDC_SELECTEDOPTION_SUBTEXT_LABEL);
 510         pSubTxtLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 511         pSubTxtLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 512         pSubTxtLbl->SetTextConfig(FONT_SIZE_SUB_TXT, LABEL_TEXT_STYLE_NORMAL);
 513         pSubTxtLbl->SetTextColor(COLOR_NORMAL_SUB_TXT);
 514         pItem->AddControl(*pSubTxtLbl);
 515
 516         pItem->SetBackgroundColor(COLOR_LIST_MENU_ITEM, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 517         //set Drop-down icon to item
 518         SetExpandIconToItem(pItem, __isWaitTimeOptionsMenuExpanded);
 519         return pItem;
 520 }
 521
 522 String
 523 SettingsForwardToNumberForm::FetchTextForSelectedOption(int selectedWaitTimeOption)
 524 {
 525         //default text
 526         String subText(L"");
 527         switch(selectedWaitTimeOption)
 528         {
 529         case WAITTIMEOPTIONS_FIVE_SEC:
 530                 subText.Append(L"5 ");
 531                 break;
 532
 533         case WAITTIMEOPTIONS_TEN_SEC:
 534                 subText.Append(L"10 ");
 535                 break;
 536
 537         case WAITTIMEOPTIONS_FIFTEEN_SEC:
 538                 subText.Append(L"15 ");
 539                 break;
 540
 541         case WAITTIMEOPTIONS_TWENTY_SEC:
 542                 subText.Append(L"20 ");
 543                 break;
 544
 545         case WAITTIMEOPTIONS_TWENTYFIVE_SEC:
 546                 subText.Append(L"25 ");
 547                 break;
 548
 549         case WAITTIMEOPTIONS_THIRTY_SEC:
 550         default:
 551                 subText.Append(L"30 ");
 552                 break;
 553         }
 554         subText.Append(AppUtility::GetResourceString(IDS_SETTING_WAIT_INTERVAL_STRING));
 555         return subText;
 556 }
 557
 558 void
 559 SettingsForwardToNumberForm::SetExpandIconToItem(TableViewItem* pItem, bool isExpanded)
 560 {
 561         Bitmap* pNormalIcon = null;
 562         Bitmap* pPressIcon = null;
 563
 564         if (!isExpanded)
 565         {
 566                 pNormalIcon = AppUtility::GetBitmapFromResourcesN(IDB_LIST_EXPAND, W_EXPAND_ICON, H_EXPAND_ICON);
 567                 pPressIcon = AppUtility::GetBitmapFromResourcesN(IDB_LIST_EXPAND_PRESSED, W_EXPAND_ICON, H_EXPAND_ICON);
 568         }
 569         else
 570         {
 571                 pNormalIcon = AppUtility::GetBitmapFromResourcesN(IDB_LIST_OPENED, W_EXPAND_ICON, H_EXPAND_ICON);
 572                 pPressIcon = AppUtility::GetBitmapFromResourcesN(IDB_LIST_OPENED_PRESSED, W_EXPAND_ICON, H_EXPAND_ICON);
 573         }
 574
 575         int itemWidth = pItem->GetWidth();
 576         Rectangle iconRect((itemWidth - W_EXPAND_ICON - X_LIST_MENU_TEXT_ITEM),
 577                                            ((H_LIST_DROPDOWN_MENU_ITEM - H_EXPAND_ICON) / 2), W_EXPAND_ICON, H_EXPAND_ICON);
 578         //for drawing blue bg header rectangle on left side.
 579         Rectangle blueHeaderRect(0,0,W_LEFT_HEADER_EXPAND_ITEMS,pItem->GetHeight());
 580         //normal canvas
 581         Canvas* pBgCanvas = new (std::nothrow) Canvas();
 582         pBgCanvas->Construct(Rectangle(0,0, pItem->GetBounds().width, pItem->GetBounds().height));
 583         pBgCanvas->DrawBitmap(iconRect, *pNormalIcon);
 584         pBgCanvas->FillRectangle(COLOR_LEFT_HEADER_EXPAND_ITEMS, blueHeaderRect);
 585         Bitmap* pActualBgBmp = new (std::nothrow) Bitmap();
 586         pActualBgBmp->Construct(*pBgCanvas,pBgCanvas->GetBounds());
 587         pItem->SetBackgroundBitmap(pActualBgBmp, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 588         delete pBgCanvas;
 589         delete pActualBgBmp;
 590         //pressed canvas
 591         pBgCanvas = new (std::nothrow) Canvas();
 592         pBgCanvas->Construct(Rectangle(0,0, pItem->GetBounds().width, pItem->GetBounds().height));
 593         pBgCanvas->DrawBitmap(iconRect, *pPressIcon);
 594         pBgCanvas->FillRectangle(COLOR_LEFT_HEADER_EXPAND_ITEMS, blueHeaderRect);
 595         pActualBgBmp = new (std::nothrow) Bitmap();
 596         pActualBgBmp->Construct(*pBgCanvas,pBgCanvas->GetBounds());
 597         pItem->SetBackgroundBitmap(pActualBgBmp, TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED);
 598         delete pBgCanvas;
 599         delete pActualBgBmp;
 600
 601         delete pNormalIcon;
 602         pNormalIcon = null;
 603         delete pPressIcon;
 604         pPressIcon = null;
 605 }
 606
 607 void
 608 SettingsForwardToNumberForm::ToggleGroupExpansion(GroupedTableView& tableView, int itemIndex)
 609 {
 610         switch (itemIndex)
 611         {
 612         case SELECTWAITTIME_WAIT_TIME:
 613         {
 614                 if (tableView.IsGroupExpanded(GROUP_WAIT_TIME_OPTIONS))
 615                 {
 616                         tableView.CollapseGroup(GROUP_WAIT_TIME_OPTIONS);
 617                         __isWaitTimeOptionsMenuExpanded = false;
 618                 }
 619                 else
 620                 {
 621                         tableView.ExpandGroup(GROUP_WAIT_TIME_OPTIONS);
 622                         __isWaitTimeOptionsMenuExpanded = true;
 623                 }
 624                 //Change icon
 625                 tableView.RefreshItem(GROUP_SELECT_WAIT_TIME, SELECTWAITTIME_WAIT_TIME, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 626         }
 627         break;
 628
 629         default:
 630         break;
 631         }
 632
 633 }
 634
 635 TableViewItem*
 636 SettingsForwardToNumberForm::CreateWaitingTimeOptionsMenuItems(int itemIndex, int itemWidth)
 637 {
 638         //create a new item
 639         TableViewItem* pItem = new (std::nothrow) TableViewItem();
 640         pItem->Construct(Dimension(itemWidth, H_LIST_NORMAL_MENU_ITEM), TABLE_VIEW_ANNEX_STYLE_RADIO);
 641         pItem->SetBackgroundColor(COLOR_SECONDDEPTH_ITEM_BG, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 642
 643         //text item rectangle
 644         Rectangle itemRect(X_LIST_MENU_TEXT_ITEM, 0, (itemWidth - X_LIST_MENU_TEXT_ITEM), H_LIST_DROPDOWN_MENU_ITEM);
 645         //Option item name
 646         String itemName(L"");
 647         GroupSelectWaitTimeItems selectedOption = (GroupSelectWaitTimeItems)((itemIndex + 1) * 5);
 648         itemName.Append(FetchTextForSelectedOption(selectedOption));
 649
 650         Label* pItemLbl = new (std::nothrow) Label();
 651         pItemLbl->Construct(itemRect, itemName);
 652         pItemLbl->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 653         pItemLbl->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
 654         pItemLbl->SetTextConfig(FONT_SIZE_MAIN_TXT, LABEL_TEXT_STYLE_NORMAL);
 655         pItemLbl->SetTextColor(COLOR_NORMAL_MAIN_TXT);//COLOR_PRESS_MAIN_TXT
 656         pItem->AddControl(*pItemLbl);
 657         return pItem;
 658 }
 659
 660 void
 661 SettingsForwardToNumberForm::HandleSelectedWaitingTime(GroupedTableView& tableView, int itemIndex, TableViewItemStatus status)
 662 {
 663         GroupWaitTimeOptionsItems currentWaitTime = (GroupWaitTimeOptionsItems) ((itemIndex + 1) * 5);
 664
 665         //check if already checked item is selected
 666         if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 667         {
 668                 tableView.SetItemChecked(GROUP_WAIT_TIME_OPTIONS, itemIndex, true);
 669                 __selectedWaitTime = currentWaitTime;
 670                 return;
 671         }
 672         //uncheck previously selected option
 673         if(__selectedWaitTime != currentWaitTime)
 674         {
 675                 int deselectIndex = ((__selectedWaitTime / 5) - 1);
 676                 tableView.SetItemChecked(GROUP_WAIT_TIME_OPTIONS, deselectIndex, false);
 677                 tableView.RefreshItem(GROUP_WAIT_TIME_OPTIONS, deselectIndex, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 678         }
 679         //update selected wait time for selected itemIndex
 680         __selectedWaitTime = currentWaitTime;
 681         //Change icon and sub text for wait time options menu
 682         tableView.RefreshItem(GROUP_SELECT_WAIT_TIME, SELECTWAITTIME_WAIT_TIME, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 683         tableView.Invalidate(true);
 684 }
 685
 686 void
 687 SettingsForwardToNumberForm::OnKeypadWillOpen(Tizen::Ui::Control& source)
 688 {
 689         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 690         if(pMainMenuTableView != null && __isWaitTimeOptionsMenuExpanded == true)
 691         {
 692                 pMainMenuTableView->CollapseGroup(GROUP_WAIT_TIME_OPTIONS);
 693                 __isWaitTimeOptionsMenuExpanded = false;
 694                 //Change icon
 695                 pMainMenuTableView->RefreshItem(GROUP_SELECT_WAIT_TIME, SELECTWAITTIME_WAIT_TIME, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 696         }
 697 }
 698
 699 void
 700 SettingsForwardToNumberForm::OnKeypadClosed(Tizen::Ui::Control& source)
 701 {
 702         GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 703         if(pMainMenuTableView != null && __isWaitTimeOptionsMenuExpanded == false)
 704         {
 705                 ToggleGroupExpansion(*pMainMenuTableView, SELECTWAITTIME_WAIT_TIME);
 706         }
 707 }
 708
 709 void
 710 SettingsForwardToNumberForm::ShowErrorMessage(int errorCode)
 711 {
 712         //show error msg Popup
 713         if (__pErrorMsgPopup == null)
 714         {
 715                 __pErrorMsgPopup = new (std::nothrow) ErrorMsgPopup(this);
 716         }
 717         __pErrorMsgPopup->ShowErrorMsgPopupN(errorCode);
 718 }
 719
 720 void
 721 SettingsForwardToNumberForm::HandlePopupClosed(void)
 722 {
 723         Draw();
 724         delete __pErrorMsgPopup;
 725         __pErrorMsgPopup = null;
 726         return;
 727 }
 728
 729 void
 730 SettingsForwardToNumberForm::HandleGetCallForwardResponse(bool isCallSuccessful, CallForwardCondition callFwdCondition, const String& callFwdNumber, bool callForwardActivated, int noReplyWaitTime)
 731 {
 732         if (callForwardActivated == true)
 733         {
 734                 //update forward number in text field
 735                 if(callFwdNumber.IsEmpty() == false)
 736                 {
 737                         EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 738                         if (pEditFieldNumber != null)
 739                         {
 740                                 pEditFieldNumber->SetText(callFwdNumber);
 741                                 pEditFieldNumber->Invalidate(true);
 742                         }
 743                 }
 744                 //update No Reply Wait time status
 745                 GroupedTableView* pMainMenuTableView = static_cast<GroupedTableView*>(GetControl(IDC_GROUPEDTABLEVIEW));
 746                 if (pMainMenuTableView != null)
 747                 {
 748                         //un-check all waiting time options
 749                         int index = 0;
 750                         while(index < IDI_WAITTIMEOPTIONS_TOTALCOUNT)
 751                         {
 752                                 pMainMenuTableView->SetItemChecked(GROUP_WAIT_TIME_OPTIONS, index, false);
 753                                 index++;
 754                         }
 755                         //enable selected wait time option
 756                         if(noReplyWaitTime >= WAITTIMEOPTIONS_FIVE_SEC)
 757                         {
 758                                 int selectedIndex = (noReplyWaitTime / WAITTIMEOPTIONS_FIVE_SEC) - 1;
 759                                 pMainMenuTableView->SetItemChecked(GROUP_WAIT_TIME_OPTIONS, selectedIndex, true);
 760                         }
 761                         pMainMenuTableView->Invalidate(true);
 762                 }
 763         }
 764 }
 765
 766 void
 767 SettingsForwardToNumberForm::LaunchContactsAppControl(void)
 768 {
 769         result r = E_SUCCESS;
 770         HashMap extraData;
 771         extraData.Construct();
 772
 773         extraData.Add(new (std::nothrow) String(SELECTION_MODE), new (std::nothrow) String(SELECTION_MODE_SINGLE));
 774         extraData.Add(new (std::nothrow) String(RETURN_TYPE), new (std::nothrow) String(RETURN_TYPE_PHONE));
 775
 776         AppControl* pAc = AppManager::FindAppControlN(PROVIDER_ID_CONTACTS, OPERATION_ID_PICK);
 777         if (pAc != null)
 778         {
 779                 r = pAc->Start(null, null, &extraData, this);
 780                 delete pAc;
 781         }
 782         extraData.RemoveAll(true);
 783 }
 784
 785 void
 786 SettingsForwardToNumberForm::OnAppControlCompleteResponseReceived(const AppId& appId, const String& operationId, AppCtrlResult appControlResult, const IMap* pExtraData)
 787 {
 788         if (appId.Equals(String(PROVIDER_ID_CONTACTS)) && operationId.Equals(String(OPERATION_ID_PICK))
 789                         && (appControlResult == APP_CTRL_RESULT_SUCCEEDED))
 790         {
 791                 const String* rettype = static_cast<const String *>(pExtraData->GetValue( String(RETURN_TYPE)));
 792                 if (rettype->Equals(String(RETURN_TYPE_PHONE)))
 793                 {
 794                         const String* pPickResult = static_cast<const String *>(pExtraData->GetValue( String(RETURN_KEY_VALUE)));
 795                         if (pPickResult != null && pPickResult->IsEmpty() == false)
 796                         {
 797                                 EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 798                                 Header* pHeader = GetHeader();
 799                                 if (pEditFieldNumber != null && pHeader != null)
 800                                 {
 801                                         pEditFieldNumber->SetText(*pPickResult);
 802                                         pEditFieldNumber->Invalidate(true);
 803                                         //enable "Done" button
 804                                         pHeader->SetItemEnabled(0, true);
 805                                         pHeader->Invalidate(true);
 806                                 }
 807                         }
 808                 }
 809         }
 810
 811 }
 812
 813 void
 814 SettingsForwardToNumberForm::OnTextValueChanged(const Control& source)
 815 {
 816         //enable or disable "Done" button
 817         EditField* pEditFieldNumber = static_cast<EditField*>(GetControl(IDC_FOWARDING_NUMBER_EDITFIELD));
 818         Header* pHeader = GetHeader();
 819         if (pEditFieldNumber != null && pHeader != null)
 820         {
 821                 bool activate = false;
 822                 if(pEditFieldNumber->GetTextLength() > 0)
 823                 {
 824                         activate = true;
 825                 }
 826                 pHeader->SetItemEnabled(0, activate);
 827                 pHeader->Invalidate(true);
 828         }
 829 }
 830
 831 void
 832 SettingsForwardToNumberForm::OnTextValueChangeCanceled(const Control& source)
 833 {
 834         //text change canceled, disable save button
 835         const EditField* pEditFieldNumber = static_cast<const EditField*>(&source);
 836         Header* pHeader = GetHeader();
 837         if (pEditFieldNumber != null && pHeader != null)
 838         {
 839                 pHeader->SetItemEnabled(0, false);
 840                 pHeader->Invalidate(true);
 841         }
 842 }
 843