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         if(__pOptionsList != null)
  90         {
  91                 delete __pOptionsList;
  92                 __pOptionsList = null;
  93         }
  94 }
  95
  96 result
  97 CallLogViewByPopup::ConstructViewbyPopup()
  98 {
  99         result r = E_SUCCESS;
 100         r = Construct(IDL_CALL_LOG_VIEWBY_POPUP);
 101         if(r == E_FAILURE)
 102         {
 103                 AppLogException("CallLogViewbyPopup construction failed");
 104                 return r;
 105         }
 106         SetPropagatedKeyEventListener(this);
 107         AppUtility::GetGlobalFontAndItemHeight(&__fontSize, &__itemHeight);
 108         //show options
 109         __pOptionsList =  new (std::nothrow) ArrayList(SingleObjectDeleter);
 110         __pOptionsList->Construct();
 111         String cmdString;
 112
 113         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_ALL_LOGS_CHKBTN_STRING);
 114         __pOptionsList->Add(new String(cmdString));
 115         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_MISSED_CALLS_CHKBTN_STRING);
 116         __pOptionsList->Add(new String(cmdString));
 117         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_DIALED_CALLS_CHKBTN_STRING);
 118         __pOptionsList->Add(new String(cmdString));
 119         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_RECEIVED_CALLS_CHKBTN_STRING);
 120         __pOptionsList->Add(new String(cmdString));
 121         cmdString = AppUtility::GetResourceString(IDS_VIEWBY_REJECTED_CALLS_CHKBTN_STRING);
 122         __pOptionsList->Add(new String(cmdString));
 123         __pPopupTitle = static_cast<Label*>(GetControl(IDL_POPUP_TITLE));
 124         if(__pPopupTitle != null)
 125         {
 126                 cmdString = AppUtility::GetResourceString(IDS_VIEWBY_POPUP_TITLE_STRING);
 127                 __pPopupTitle->SetTextConfig(__fontSize, LABEL_TEXT_STYLE_NORMAL);
 128                 __pPopupTitle->SetText(cmdString);
 129         }
 130
 131         __pListView = new (std::nothrow) ListView();
 132         __pListView->Construct(Rectangle(0, __pPopupTitle->GetHeight() + POPUP_TITLE_PADDING, W_POPUP, H_LIST), true, SCROLL_STYLE_FADE_OUT);
 133         __pListView->AddListViewItemEventListener(*this);
 134         __pListView->SetItemProvider(*this);
 135         r = AddControl(__pListView);
 136
 137         String strText;
 138         Application::GetInstance()->GetAppResource()->GetString(L"IDS_CANCEL", strText);
 139         Button* pCancelButton = new (std::nothrow) Button();
 140         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);
 141         pCancelButton->SetActionId(IDA_CANCEL);
 142         pCancelButton->AddActionEventListener(*this);
 143         r = AddControl(pCancelButton);
 144         TryReturn(r == E_SUCCESS, r, "CallOptionPopup::AddControl() failed");
 145
 146         __pListView->UpdateList();
 147         __pListView->SetItemChecked(__selectedViewByIndex, true);
 148         __pListView->Invalidate(true);
 149         return r;
 150 }
 151
 152 int
 153 CallLogViewByPopup::GetItemCount(void)
 154 {
 155         if (__pOptionsList != null)
 156         {
 157                 return __pOptionsList->GetCount();
 158         }
 159         return 0;
 160 }
 161
 162 ListItemBase*
 163 CallLogViewByPopup::CreateItem(int index, int itemWidth)
 164 {
 165         String* strText = static_cast<String*>(__pOptionsList->GetAt(index));
 166         ListAnnexStyle style = LIST_ANNEX_STYLE_RADIO;
 167         CustomItem* pItem = new CustomItem();
 168         //pItem->Construct(Dimension(itemWidth, H_LIST_ITEM), style);
 169         //pItem->AddElement(Rectangle(HORIZONTAL_PADDING, 0, W_POPUP - HORIZONTAL_PADDING, H_LIST_ITEM), index, *strText);
 170         pItem->Construct(Dimension(itemWidth, H_LIST_ITEM + 8), style);
 171         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);
 172
 173         return pItem;
 174 }
 175
 176 void
 177 CallLogViewByPopup::OnListViewItemStateChanged(ListView& listView, int index, int elementId, ListItemStatus status)
 178 {
 179         switch(index)
 180         {
 181         case IDA_ALL_LOGS:
 182         {
 183                 Popup::SetShowState(false);
 184                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_ALL);
 185                 __selectedViewByIndex = IDA_ALL_LOGS;
 186                 __popupListener.OnItemSelected();
 187         }
 188         break;
 189
 190         case IDA_MISSED_CALLS:
 191         {
 192                 Popup::SetShowState(false);
 193                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_MISSED);
 194                 __selectedViewByIndex = IDA_MISSED_CALLS;
 195                 __popupListener.OnItemSelected();
 196         }
 197         break;
 198
 199         case IDA_DIALED_CALLS:
 200         {
 201                 Popup::SetShowState(false);
 202                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_OUTGOING);
 203                 __selectedViewByIndex = IDA_DIALED_CALLS;
 204                 __popupListener.OnItemSelected();
 205         }
 206         break;
 207
 208         case IDA_RECEIVED_CALLS:
 209         {
 210                 Popup::SetShowState(false);
 211                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_INCOMING);
 212                 __selectedViewByIndex = IDA_RECEIVED_CALLS;
 213                 __popupListener.OnItemSelected();
 214         }
 215         break;
 216
 217         case IDA_REJECTED_CALLS:
 218         {
 219                 Popup::SetShowState(false);
 220                 CalLogPresentationModel::setCallLogViewbyID(CALL_LOG_TYPE_VOICE_REJECTED);
 221                 __selectedViewByIndex = IDA_REJECTED_CALLS;
 222                 __popupListener.OnItemSelected();
 223         }
 224         break;
 225
 226         case IDA_CANCEL:
 227         {
 228                 Popup::SetShowState(false);
 229         }
 230         break;
 231         }
 232
 233         return;
 234 }
 235
 236 bool
 237 CallLogViewByPopup::DeleteItem(int index, ListItemBase* pItem, int itemWidth)
 238 {
 239         delete pItem;
 240         pItem = null;
 241         return true;
 242 }
 243
 244 void
 245 CallLogViewByPopup::UpdateViewByPopupList()
 246 {
 247         AppUtility::GetGlobalFontAndItemHeight(&__fontSize, &__itemHeight);
 248         __pPopupTitle->SetTextConfig(__fontSize, LABEL_TEXT_STYLE_NORMAL);
 249         __pPopupTitle->Invalidate(true);
 250         __pListView->UpdateList();
 251         __pListView->Invalidate(true);
 252 }
 253
 254 result
 255 CallLogViewByPopup::ConstructBlockPopup(Tizen::Base::String& phoneNumber, bool isCallRejected, bool isMsgBeRejected)
 256 {
 257         result r = E_SUCCESS;
 258         r = Construct(IDL_CALL_BLOCK_POPUP);
 259         if(r == E_FAILURE)
 260         {
 261                 AppLogException("CallBlockPopup construction failed");
 262                 return r;
 263         }
 264         SetPropagatedKeyEventListener(this);
 265         __pPopupTitle = static_cast<Label*>(GetControl(IDL_POPUP_TITLE));
 266         __pButtonBlockCall = static_cast<CheckButton*>(GetControl(IDC_BLOCK_CALL));
 267         __pButtonBlockMessage = static_cast<CheckButton*>(GetControl(IDC_BLOCK_MESSAGE));
 268         __pBlockInfo = static_cast<Label*>(GetControl(IDC_BLOCK_INFO));
 269         __pButtonBlockOk = static_cast<Button*>(GetControl(IDC_BLOCK_OK));
 270         __pButtonBlockCancel = static_cast<Button*>(GetControl(IDC_BLOCK_CANCEL));
 271
 272         String cmdString;
 273         if(__pPopupTitle != null)
 274         {
 275                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_POPUP_TITLE_STRING);
 276                 cmdString.Append(" ");
 277                 cmdString.Append(phoneNumber);
 278                 __pPopupTitle->SetText(cmdString);
 279
 280         }
 281         if(__pBlockInfo != null)
 282         {
 283                 __pBlockInfo->SetShowState(false);
 284         }
 285         if(__pButtonBlockCall != null)
 286         {
 287                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_CHKBTN_STRING);
 288                 __pButtonBlockCall->SetText(cmdString);
 289                 __pButtonBlockCall->SetActionId(IDA_BLOCK_CALL, IDA_BLOCK_CALL);
 290                 __pButtonBlockCall->AddActionEventListener(*this);
 291         }
 292         if(__pButtonBlockMessage != null)
 293         {
 294                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_MESSAGE_CHKBTN_STRING);
 295                 __pButtonBlockMessage->SetText(cmdString);
 296                 __pButtonBlockMessage->SetActionId(IDA_BLOCK_MESSAGE, IDA_BLOCK_MESSAGE);
 297                 __pButtonBlockMessage->AddActionEventListener(*this);
 298         }
 299         if(__pButtonBlockOk != null)
 300         {
 301                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_OK_BTN_STRING);
 302                 __pButtonBlockOk->SetText(cmdString);
 303                 __pButtonBlockOk->SetActionId(IDA_BLOCK_OK);
 304                 __pButtonBlockOk->AddActionEventListener(*this);
 305                 __pButtonBlockOk->SetEnabled(false);
 306         }
 307         if(__pButtonBlockCancel != null)
 308         {
 309                 cmdString = AppUtility::GetResourceString(IDS_BLOCK_CANCEL_BTN_STRING);
 310                 __pButtonBlockCancel->SetText(cmdString);
 311                 __pButtonBlockCancel->SetActionId(IDA_BLOCK_CANCEL);
 312                 __pButtonBlockCancel->AddActionEventListener(*this);
 313         }
 314         if(__pButtonBlockCall == null || __pButtonBlockOk == null || __pButtonBlockCancel == null)
 315         {
 316                 return r;
 317         }
 318         if((isCallRejected == true || isMsgBeRejected ==true) && __pBlockInfo != null)
 319         {
 320                 if(isCallRejected == true && isMsgBeRejected ==true)
 321                 {
 322                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_MSG_INFO_STRING);
 323                 }
 324                 else if(isCallRejected == true)
 325                 {
 326                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_CALL_INFO_STRING);
 327                 }
 328                 else
 329                 {
 330                         cmdString = AppUtility::GetResourceString(IDS_BLOCK_MSG_INFO_STRING);
 331                 }
 332
 333                 __pBlockInfo->SetText(cmdString);
 334                 __pBlockInfo->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
 335                 __pBlockInfo->SetShowState(isCallRejected || isMsgBeRejected);
 336
 337                 __pButtonBlockCall->SetSelected(isCallRejected);
 338                 __pButtonBlockCall->SetEnabled(!isCallRejected);
 339                 __pButtonBlockCall->SetPosition(__pButtonBlockCall->GetX(), __pButtonBlockCall->GetY() + H_LIST_ITEM);
 340                 __pButtonBlockCall->SetBounds(__pButtonBlockCall->GetX(), __pButtonBlockCall->GetY(), __pButtonBlockCall->GetWidth(), __pButtonBlockCall->GetHeight());
 341                 __pButtonBlockMessage->SetSelected(isMsgBeRejected);
 342                 __pButtonBlockMessage->SetEnabled(!isMsgBeRejected);
 343                 __pButtonBlockMessage->SetPosition(__pButtonBlockMessage->GetX(), __pButtonBlockMessage->GetY() + H_LIST_ITEM);
 344                 __pButtonBlockMessage->SetBounds(__pButtonBlockMessage->GetX(), __pButtonBlockMessage->GetY(), __pButtonBlockMessage->GetWidth(), __pButtonBlockMessage->GetHeight());
 345                 __pButtonBlockOk->SetPosition(__pButtonBlockOk->GetX(), __pButtonBlockOk->GetY() + H_LIST_ITEM);
 346                 __pButtonBlockCancel->SetPosition(__pButtonBlockCancel->GetX(), __pButtonBlockCancel->GetY() + H_LIST_ITEM);
 347                 SetBounds(GetX(), GetY(), GetWidth(), GetHeight() + H_LIST_ITEM);
 348         }
 349         else
 350         {
 351                 __pButtonBlockOk->SetBounds(__pButtonBlockOk->GetX(), __pButtonBlockOk->GetY(), __pButtonBlockOk->GetWidth(), __pButtonBlockOk->GetHeight());
 352                 __pButtonBlockCancel->SetBounds(__pButtonBlockCancel->GetX(), __pButtonBlockCancel->GetY(), __pButtonBlockCancel->GetWidth(), __pButtonBlockCancel->GetHeight());
 353         }
 354
 355         return r;
 356 }
 357
 358 void
 359 CallLogViewByPopup::OnActionPerformed(const Control& source, int actionId)
 360 {
 361         switch(actionId)
 362         {
 363         case IDA_BLOCK_CALL:
 364         {
 365                 __isBlockCallSelected = !__isBlockCallSelected;
 366                 __pButtonBlockOk->SetEnabled(__isBlockCallSelected || __isBlockMessageSelected);
 367                 __pButtonBlockOk->Invalidate(__isBlockCallSelected || __isBlockMessageSelected);
 368         }
 369         break;
 370
 371         case IDA_BLOCK_MESSAGE:
 372         {
 373                 __isBlockMessageSelected = !__isBlockMessageSelected;
 374                 __pButtonBlockOk->SetEnabled(__isBlockCallSelected || __isBlockMessageSelected);
 375                 __pButtonBlockOk->Invalidate(__isBlockCallSelected || __isBlockMessageSelected);
 376         }
 377         break;
 378
 379         case IDA_CANCEL:
 380         {
 381                 Popup::SetShowState(false);
 382         }
 383         break;
 384
 385         case IDA_BLOCK_OK:
 386         {
 387                 Popup::SetShowState(false);
 388                 __popupListener.OnItemSelected();
 389         }
 390         break;
 391
 392         case IDA_BLOCK_CANCEL:
 393         {
 394                 Popup::SetShowState(false);
 395         }
 396         break;
 397
 398         default:break;
 399
 400         }
 401 }
 402
 403 bool
 404 CallLogViewByPopup::GetCallBlock()
 405 {
 406         return __isBlockCallSelected;
 407 }
 408
 409 bool
 410 CallLogViewByPopup::GetMessageBlock()
 411 {
 412         return __isBlockMessageSelected;
 413 }
 414
 415 bool
 416 CallLogViewByPopup::OnKeyPressed(Control& source, const KeyEventInfo& keyEventInfo)
 417 {
 418         AppLogDebug("Enter");
 419         if(keyEventInfo.GetKeyCode() == KEY_BACK)
 420         {
 421                 Popup::SetShowState(false);
 422         }
 423         return false;
 424 }
 425
 426