src/PhnCallLogViewByPopup.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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        PhnCallLogViewByPopup.cpp
  19  * @brief       The Logs Tab
  20  */
  21
  22 #include <FApp.h>
  23 #include <FSocial.h>
  24 #include <FSystem.h>
  25 #include <FUi.h>
  26 #include <FGraphics.h>
  27 #include "PhnAppUtility.h"
  28 #include "PhnCallLogViewByPopup.h"
  29 #include "PhnCallLogPresentationModel.h"\r
  30 #include "PhnTabLogs.h"
  31 #include "PhnTypes.h"
  32
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Base::Utility;
  36 using namespace Tizen::App;
  37 using namespace Tizen::Graphics;
  38 using namespace Tizen::Social;
  39 using namespace Tizen::Ui;
  40 using namespace Tizen::Ui::Controls;
  41 using namespace Tizen::Ui::Scenes;
  42
  43 static const wchar_t* IDC_BLOCK_CALL = L"IDC_BLOCK_CALL";
  44 static const wchar_t* IDC_BLOCK_MESSAGE = L"IDC_BLOCK_MESSAGE";
  45 static const wchar_t* IDC_BLOCK_OK = L"IDC_BLOCK_OK";
  46 static const wchar_t* IDC_BLOCK_CANCEL = L"IDC_BLOCK_CANCEL";
  47 static const wchar_t* IDC_BLOCK_INFO = L"IDC_BLOCK_INFO";
  48 static const wchar_t* IDL_CALL_LOG_VIEWBY_POPUP = L"IDL_CALL_LOG_VIEWBY_POPUP";
  49 static const wchar_t* IDL_CALL_BLOCK_POPUP = L"IDL_CALL_BLOCK_POPUP";
  50 static const wchar_t* IDL_POPUP_TITLE = L"IDC_POPUP_TITLE";
  51
  52 const int W_POPUP = 600;
  53 const int H_POPUP = 520;
  54 const int H_POPUP_TITLE = 72;
  55 const int POPUP_TITLE_PADDING = 20;
  56 const int W_CANCEL_BUTTON = 350;
  57 const int H_CANCEL_BUTTON = 72;
  58 const int CANCEL_BUTTON_PADDING = 30;
  59 const int H_LIST = 300;
  60 const int H_LIST_ITEM = 112;
  61 const int W_LIST_ITEM = 112;
  62 const int HORIZONTAL_PADDING = 16;
  63 const int VERTICAL_PADDING = 85;
  64
  65 int CallLogViewByPopup::__selectedViewByIndex = IDA_ALL_LOGS;
  66
  67 CallLogViewByPopup::CallLogViewByPopup(ICallLogViewByPopupListener& listener)
  68         : __popupListener(listener)
  69 {
  70         __pPopupTitle = null;
  71         __pButtonAllLogs = null;
  72         __pButtonMissedCalls = null;
  73         __pButtonDialedCalls = null;
  74         __pButtonReceivedCalls = null;
  75         __pButtonRejectedCalls = null;
  76         __pButtonBlockCall = null;
  77         __pButtonBlockMessage = null;
  78         __pButtonCancel = null;
  79         __pButtonBlockOk = null;
  80         __pButtonBlockCancel = null;
  81         __pBlockInfo = null;
  82         __isBlockCallSelected = false;
  83         __isBlockMessageSelected = false;
  84         __pListView = null;
  85 }
  86
  87 CallLogViewByPopup::~CallLogViewByPopup()
  88 {
  89 }
  90
  91 result
  92 CallLogViewByPopup::ConstructViewbyPopup()
  93 {
  94         result r = E_SUCCESS;
  95         r = Construct(IDL_CALL_LOG_VIEWBY_POPUP);
  96         if(r == E_FAILURE)
  97         {
  98                 AppLogException("CallLogViewbyPopup construction failed");
  99                 return r;
 100         }
 101         SetPropagatedKeyEventListener(this);
 102         AppUtility::GetGlobalFontAndItemHeight(&__fontSize, &__itemHeight);
 103         //show options
 104         __pOptionsList =  new (std::nothrow) ArrayList(SingleObjectDeleter);
 105         __pOptionsList->Construct();
 106         String cmdString;
 107
 108         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_ALL_LOGS_CHKBTN_STRING);
 109         __pOptionsList->Add(new String(cmdString));
 110         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_MISSED_CALLS_CHKBTN_STRING);
 111         __pOptionsList->Add(new String(cmdString));
 112         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_DIALED_CALLS_CHKBTN_STRING);
 113         __pOptionsList->Add(new String(cmdString));
 114         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_RECEIVED_CALLS_CHKBTN_STRING);
 115         __pOptionsList->Add(new String(cmdString));
 116         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_REJECTED_CALLS_CHKBTN_STRING);
 117         __pOptionsList->Add(new String(cmdString));
 118         __pPopupTitle = static_cast<Label*>(GetControl(IDL_POPUP_TITLE));
 119         if(__pPopupTitle != null)
 120         {
 121                 cmdString = AppUtility::GetResourceString(IDS_VIEWBY_POPUP_TITLE_STRING);
 122                 __pPopupTitle->SetTextConfig(__fontSize, LABEL_TEXT_STYLE_NORMAL);
 123                 __pPopupTitle->SetText(cmdString);
 124         }
 125
 126         __pListView = new (std::nothrow) ListView();
 127         __pListView->Construct(Rectangle(0, __pPopupTitle->GetHeight() + POPUP_TITLE_PADDING, W_POPUP, H_LIST), true, SCROLL_STYLE_FADE_OUT);
 128         __pListView->AddListViewItemEventListener(*this);
 129         __pListView->SetItemProvider(*this);
 130         r = AddControl(__pListView);
 131
 132         String strText;
 133         Application::GetInstance()->GetAppResource()->GetString(L"IDS_CANCEL", strText);
 134         Button* pCancelButton = new (std::nothrow) Button();
 135         r = pCancelButton->Construct(Rectangle(((W_POPUP - W_CANCEL_BUTTON)/2), __pPopupTitle->GetHeight() + POPUP_TITLE_PADDING + __pListView->GetHeight() + CANCEL_BUTTON_PADDING, W_CANCEL_BUTTON, H_CANCEL_BUTTON), strText);
 136         pCancelButton->SetActionId(IDA_CANCEL);
 137         pCancelButton->AddActionEventListener(*this);
 138         r = AddControl(pCancelButton);
 139         TryReturn(r == E_SUCCESS, r, "CallOptionPopup::AddControl() failed");
 140
 141         __pListView->UpdateList();
 142         __pListView->SetItemChecked(__selectedViewByIndex, true);
 143         __pListView->Invalidate(true);
 144         return r;
 145 }
 146
 147 int
 148 CallLogViewByPopup::GetItemCount(void)
 149 {
 150         if (__pOptionsList != null)
 151         {
 152                 return __pOptionsList->GetCount();
 153         }
 154         return 0;
 155 }
 156
 157 ListItemBase*
 158 CallLogViewByPopup::CreateItem(int index, int itemWidth)
 159 {
 160         String* strText = static_cast<String*>(__pOptionsList->GetAt(index));
 161         ListAnnexStyle style = LIST_ANNEX_STYLE_RADIO;
 162         CustomItem* pItem = new CustomItem();
 163         //pItem->Construct(Dimension(itemWidth, H_LIST_ITEM), style);
 164         //pItem->AddElement(Rectangle(HORIZONTAL_PADDING, 0, W_POPUP - HORIZONTAL_PADDING, H_LIST_ITEM), index, *strText);
 165         pItem->Construct(Dimension(itemWidth, H_LIST_ITEM + 8), style);
 166         pItem->AddElement(Rectangle(HORIZONTAL_PADDING, 0, W_POPUP - HORIZONTAL_PADDING - 105, H_LIST_ITEM + 8), index, *strText,__fontSize, Color::GetColor(COLOR_ID_BLACK), Color::GetColor(COLOR_ID_BLACK), Color::GetColor(COLOR_ID_BLACK), true);
 167
 168         return pItem;
 169 }
 170
 171 void
 172 CallLogViewByPopup::OnListViewItemStateChanged(ListView& listView, int index, int elementId, ListItemStatus status)
 173 {
 174         switch(index)
 175         {
 176         case IDA_ALL_LOGS:
 177         {
 178                 Popup::SetShowState(false);
 179                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_ALL);
 180                 __selectedViewByIndex = IDA_ALL_LOGS;
 181                 __popupListener.OnItemSelected();
 182         }
 183         break;
 184
 185         case IDA_MISSED_CALLS:
 186         {
 187                 Popup::SetShowState(false);
 188                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_MISSED);
 189                 __selectedViewByIndex = IDA_MISSED_CALLS;
 190                 __popupListener.OnItemSelected();
 191         }
 192         break;
 193
 194         case IDA_DIALED_CALLS:
 195         {
 196                 Popup::SetShowState(false);
 197                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_OUTGOING);
 198                 __selectedViewByIndex = IDA_DIALED_CALLS;
 199                 __popupListener.OnItemSelected();
 200         }
 201         break;
 202
 203         case IDA_RECEIVED_CALLS:
 204         {
 205                 Popup::SetShowState(false);
 206                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_INCOMING);
 207                 __selectedViewByIndex = IDA_RECEIVED_CALLS;
 208                 __popupListener.OnItemSelected();
 209         }
 210         break;
 211
 212         case IDA_REJECTED_CALLS:
 213         {
 214                 Popup::SetShowState(false);
 215                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_REJECTED);
 216                 __selectedViewByIndex = IDA_REJECTED_CALLS;
 217                 __popupListener.OnItemSelected();
 218         }
 219         break;
 220
 221         case IDA_CANCEL:
 222         {
 223                 Popup::SetShowState(false);
 224         }
 225         break;
 226         }
 227
 228         return;
 229 }
 230
 231 bool
 232 CallLogViewByPopup::DeleteItem(int index, ListItemBase* pItem, int itemWidth)
 233 {
 234         delete pItem;
 235         pItem = null;
 236         return true;
 237 }
 238
 239 void
 240 CallLogViewByPopup::UpdateViewByPopupList()
 241 {
 242         AppUtility::GetGlobalFontAndItemHeight(&__fontSize, &__itemHeight);
 243         __pPopupTitle->SetTextConfig(__fontSize, LABEL_TEXT_STYLE_NORMAL);
 244         __pPopupTitle->Invalidate(true);
 245         __pListView->UpdateList();
 246         __pListView->Invalidate(true);
 247 }
 248
 249 result
 250 CallLogViewByPopup::ConstructBlockPopup(Tizen::Base::String& phoneNumber, bool isCallRejected, bool isMsgBeRejected)
 251 {
 252         result r = E_SUCCESS;
 253         r = Construct(IDL_CALL_BLOCK_POPUP);
 254         if(r == E_FAILURE)
 255         {
 256                 AppLogException("CallBlockPopup construction failed");
 257                 return r;
 258         }
 259         SetPropagatedKeyEventListener(this);
 260         __pPopupTitle = static_cast<Label*>(GetControl(IDL_POPUP_TITLE));
 261         __pButtonBlockCall = static_cast<CheckButton*>(GetControl(IDC_BLOCK_CALL));
 262         __pButtonBlockMessage = static_cast<CheckButton*>(GetControl(IDC_BLOCK_MESSAGE));
 263         __pBlockInfo = static_cast<Label*>(GetControl(IDC_BLOCK_INFO));
 264         __pButtonBlockOk = static_cast<Button*>(GetControl(IDC_BLOCK_OK));
 265         __pButtonBlockCancel = static_cast<Button*>(GetControl(IDC_BLOCK_CANCEL));
 266
 267         String cmdString;
 268         if(__pPopupTitle != null)
 269         {
 270                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_POPUP_TITLE_STRING);
 271                 cmdString.Append(" ");
 272                 cmdString.Append(phoneNumber);
 273                 __pPopupTitle->SetText(cmdString);
 274
 275         }
 276         if(__pBlockInfo != null)
 277         {
 278                 __pBlockInfo->SetShowState(false);
 279         }
 280         if(__pButtonBlockCall != null)
 281         {
 282                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_CHKBTN_STRING);
 283                 __pButtonBlockCall->SetText(cmdString);
 284                 __pButtonBlockCall->SetActionId(IDA_BLOCK_CALL, IDA_BLOCK_CALL);
 285                 __pButtonBlockCall->AddActionEventListener(*this);
 286         }
 287         if(__pButtonBlockMessage != null)
 288         {
 289                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_MESSAGE_CHKBTN_STRING);
 290                 __pButtonBlockMessage->SetText(cmdString);
 291                 __pButtonBlockMessage->SetActionId(IDA_BLOCK_MESSAGE, IDA_BLOCK_MESSAGE);
 292                 __pButtonBlockMessage->AddActionEventListener(*this);
 293         }
 294         if(__pButtonBlockOk != null)
 295         {
 296                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_OK_BTN_STRING);
 297                 __pButtonBlockOk->SetText(cmdString);
 298                 __pButtonBlockOk->SetActionId(IDA_BLOCK_OK);
 299                 __pButtonBlockOk->AddActionEventListener(*this);
 300                 __pButtonBlockOk->SetEnabled(false);
 301         }
 302         if(__pButtonBlockCancel != null)
 303         {
 304                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_CANCEL_BTN_STRING);
 305                 __pButtonBlockCancel->SetText(cmdString);
 306                 __pButtonBlockCancel->SetActionId(IDA_BLOCK_CANCEL);
 307                 __pButtonBlockCancel->AddActionEventListener(*this);
 308         }
 309         if(__pButtonBlockCall == null || __pButtonBlockOk == null || __pButtonBlockCancel == null)
 310         {
 311                 return r;
 312         }
 313         if((isCallRejected == true || isMsgBeRejected ==true) && __pBlockInfo != null)
 314         {
 315                 if(isCallRejected == true && isMsgBeRejected ==true)
 316                 {
 317                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_MSG_INFO_STRING);
 318                 }
 319                 else if(isCallRejected == true)
 320                 {
 321                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_INFO_STRING);
 322                 }
 323                 else
 324                 {
 325                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_MSG_INFO_STRING);
 326                 }
 327
 328                 __pBlockInfo->SetText(cmdString);
 329                 __pBlockInfo->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
 330                 __pBlockInfo->SetShowState(isCallRejected || isMsgBeRejected);
 331
 332                 __pButtonBlockCall->SetSelected(isCallRejected);
 333                 __pButtonBlockCall->SetEnabled(!isCallRejected);
 334                 __pButtonBlockCall->SetPosition(__pButtonBlockCall->GetX(), __pButtonBlockCall->GetY() + H_LIST_ITEM);
 335                 __pButtonBlockCall->SetBounds(__pButtonBlockCall->GetX(), __pButtonBlockCall->GetY(), __pButtonBlockCall->GetWidth(), __pButtonBlockCall->GetHeight());
 336                 __pButtonBlockMessage->SetSelected(isMsgBeRejected);
 337                 __pButtonBlockMessage->SetEnabled(!isMsgBeRejected);
 338                 __pButtonBlockMessage->SetPosition(__pButtonBlockMessage->GetX(), __pButtonBlockMessage->GetY() + H_LIST_ITEM);
 339                 __pButtonBlockMessage->SetBounds(__pButtonBlockMessage->GetX(), __pButtonBlockMessage->GetY(), __pButtonBlockMessage->GetWidth(), __pButtonBlockMessage->GetHeight());
 340                 __pButtonBlockOk->SetPosition(__pButtonBlockOk->GetX(), __pButtonBlockOk->GetY() + H_LIST_ITEM);
 341                 __pButtonBlockCancel->SetPosition(__pButtonBlockCancel->GetX(), __pButtonBlockCancel->GetY() + H_LIST_ITEM);
 342                 SetBounds(GetX(), GetY(), GetWidth(), GetHeight() + H_LIST_ITEM);
 343         }
 344         else
 345         {
 346                 __pButtonBlockOk->SetBounds(__pButtonBlockOk->GetX(), __pButtonBlockOk->GetY(), __pButtonBlockOk->GetWidth(), __pButtonBlockOk->GetHeight());
 347                 __pButtonBlockCancel->SetBounds(__pButtonBlockCancel->GetX(), __pButtonBlockCancel->GetY(), __pButtonBlockCancel->GetWidth(), __pButtonBlockCancel->GetHeight());
 348         }
 349
 350         return r;
 351 }
 352
 353 void
 354 CallLogViewByPopup::OnActionPerformed(const Control& source, int actionId)
 355 {
 356         switch(actionId)
 357         {
 358         case IDA_BLOCK_CALL:
 359         {
 360                 __isBlockCallSelected = !__isBlockCallSelected;
 361                 __pButtonBlockOk->SetEnabled(__isBlockCallSelected || __isBlockMessageSelected);
 362                 __pButtonBlockOk->Invalidate(__isBlockCallSelected || __isBlockMessageSelected);
 363         }
 364         break;
 365
 366         case IDA_BLOCK_MESSAGE:
 367         {
 368                 __isBlockMessageSelected = !__isBlockMessageSelected;
 369                 __pButtonBlockOk->SetEnabled(__isBlockCallSelected || __isBlockMessageSelected);
 370                 __pButtonBlockOk->Invalidate(__isBlockCallSelected || __isBlockMessageSelected);
 371         }
 372         break;
 373
 374         case IDA_CANCEL:
 375         {
 376                 Popup::SetShowState(false);
 377         }
 378         break;
 379
 380         case IDA_BLOCK_OK:
 381         {
 382                 Popup::SetShowState(false);
 383                 __popupListener.OnItemSelected();
 384         }
 385         break;
 386
 387         case IDA_BLOCK_CANCEL:
 388         {
 389                 Popup::SetShowState(false);
 390         }
 391         break;
 392
 393         default:break;
 394
 395         }
 396 }
 397
 398 bool
 399 CallLogViewByPopup::GetCallBlock()
 400 {
 401         return __isBlockCallSelected;
 402 }
 403
 404 bool
 405 CallLogViewByPopup::GetMessageBlock()
 406 {
 407         return __isBlockMessageSelected;
 408 }
 409
 410 bool
 411 CallLogViewByPopup::OnKeyPressed(Control& source, const KeyEventInfo& keyEventInfo)
 412 {
 413         AppLogDebug("Enter");
 414         if(keyEventInfo.GetKeyCode() == KEY_BACK)
 415         {
 416                 Popup::SetShowState(false);
 417         }
 418         return false;
 419 }
 420
 421