src/ui/controls/FUiCtrl_DateTimeBar.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FUiCtrl_DateTimeBar.cpp
  20  * @brief               This is the implementation file for the _DateTimeBar class.
  21  */
  22
  23 #include "FUiAnim_VisualElement.h"
  24 #include "FUi_AccessibilityContainer.h"
  25 #include "FUi_AccessibilityElement.h"
  26 #include "FUi_ResourceManager.h"
  27 #include "FUiCtrl_DateTimeBar.h"
  28 #include "FUiCtrl_DateTimeBarPresenter.h"
  29 #include "FUiCtrl_ActionEvent.h"
  30 #include "FUiCtrl_Frame.h"
  31 #include "FUiCtrl_Form.h"
  32
  33 using namespace Tizen::Graphics;
  34 using namespace Tizen::Media;
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Collection;
  37 using namespace Tizen::Ui::Animations;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41 _DateTimeBar::_DateTimeBar(void)
  42         : __pDateTimeBarPresenter(null)
  43         , __pActionEvent(null)
  44         , __selectedBoxId(DATETIME_ID_NONE)
  45         , __alignment(DATETIME_BAR_ALIGN_DOWN)
  46         , __pDateTimeChangeEvent(null)
  47         , __pGestureFlick(null)
  48         , __parentWindowBounds(0, 0, 0, 0)
  49 {
  50
  51 }
  52
  53 _DateTimeBar::~_DateTimeBar(void)
  54 {
  55         if (__pDateTimeChangeEvent != null)
  56         {
  57                 delete __pDateTimeChangeEvent;
  58                 __pDateTimeChangeEvent = null;
  59         }
  60
  61         if (__pActionEvent)
  62         {
  63                 delete __pActionEvent;
  64                 __pActionEvent = null;
  65         }
  66
  67         delete __pDateTimeBarPresenter;
  68         __pDateTimeBarPresenter = null;
  69
  70         delete __pGestureFlick;
  71         __pGestureFlick = null;
  72
  73         RemoveAllAccessibilityElement();
  74
  75         ClearLastResult();
  76 }
  77
  78 _DateTimeBar*
  79 _DateTimeBar::CreateDateTimeBarN(void)
  80 {
  81         result r = E_SUCCESS;
  82         ClearLastResult();
  83
  84         _DateTimeBar* pDateTimeBar = new (std::nothrow) _DateTimeBar;
  85         SysTryReturn(NID_UI_CTRL, pDateTimeBar != null, null, E_OUT_OF_MEMORY,
  86                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
  87
  88 #if defined(MULTI_WINDOW)
  89         r = pDateTimeBar->CreateRootVisualElement();
  90         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  91 #endif
  92
  93         pDateTimeBar->__pDateTimeBarPresenter = _DateTimeBarPresenter::CreateInstanceN(*pDateTimeBar);
  94         r = GetLastResult();
  95         SysTryCatch(NID_UI_CTRL, pDateTimeBar->__pDateTimeBarPresenter != null, , r,
  96                         "[%s] Propagating.", GetErrorMessage(r));
  97
  98         pDateTimeBar->__pDateTimeChangeEvent = new (std::nothrow) _DateTimeChangeEvent(*pDateTimeBar);
  99         SysTryCatch(NID_UI_CTRL, (pDateTimeBar->__pDateTimeChangeEvent != null), , E_OUT_OF_MEMORY,
 100                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 101
 102         pDateTimeBar->AcquireHandle();
 103
 104         if (pDateTimeBar->GetVisualElement() != null)
 105         {
 106                 pDateTimeBar->GetVisualElement()->SetSurfaceOpaque(false);
 107         }
 108
 109         pDateTimeBar->__pGestureFlick = new (std::nothrow) _TouchFlickGestureDetector();
 110         SysTryCatch(NID_UI_CTRL, (pDateTimeBar->__pGestureFlick != null), , E_OUT_OF_MEMORY,
 111                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 112
 113         pDateTimeBar->AddGestureDetector(*(pDateTimeBar->__pGestureFlick));
 114         SysTryCatch(NID_UI_CTRL, (GetLastResult() == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 115
 116         r = pDateTimeBar->__pGestureFlick->AddGestureListener(*pDateTimeBar);
 117         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 118
 119         pDateTimeBar->InitializeAccessibilityElement();
 120         return pDateTimeBar;
 121
 122 CATCH:
 123         delete pDateTimeBar;
 124         return null;
 125 }
 126
 127 result
 128 _DateTimeBar::SetPositionAndAlignment(const Point& point, _DateTimeBarAlignment alignment)
 129 {
 130         ClearLastResult();
 131
 132         result r = E_SUCCESS;
 133         SetAlignment(alignment);
 134
 135         r = __pDateTimeBarPresenter->LoadArrowBitmap();
 136         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 137
 138         int height = 0;
 139
 140         r = GET_SHAPE_CONFIG(DATETIMEBAR::ITEM_HEIGHT, GetOrientation(), height);
 141         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 142
 143         SetMovable(true);
 144         SetResizable(true);
 145
 146         if (alignment == DATETIME_BAR_ALIGN_DOWN)
 147         {
 148                 SetPosition(Point(point.x, point.y));
 149
 150         }
 151         else
 152         {
 153                 SetPosition(Point(point.x, point.y - height));
 154         }
 155
 156         __pDateTimeBarPresenter->CalculateWindowBounds();
 157
 158         return r;
 159 }
 160
 161 _DateTimeBarAlignment
 162 _DateTimeBar::GetAlignment(void) const
 163 {
 164         return __alignment;
 165 }
 166
 167 void
 168 _DateTimeBar::SetAlignment(_DateTimeBarAlignment alignment)
 169 {
 170         __alignment = alignment;
 171         return;
 172 }
 173
 174 void
 175 _DateTimeBar::OnDraw(void)
 176 {
 177         ClearLastResult();
 178
 179         __pDateTimeBarPresenter->Draw();
 180         return;
 181 }
 182
 183 result
 184 _DateTimeBar::RemoveAllItems(void)
 185 {
 186         ClearLastResult();
 187
 188         result r = E_SUCCESS;
 189
 190         r = __pDateTimeBarPresenter->RemoveAllItems();
 191         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 192
 193         return r;
 194 }
 195
 196 result
 197 _DateTimeBar::SetInitialValue(int minValue, int maxValue, int displayValue, _DateTimeId boxId)
 198 {
 199         ClearLastResult();
 200
 201         result r = E_SUCCESS;
 202
 203         SetSelectedBoxId(boxId);
 204
 205         __pDateTimeBarPresenter->SetMinimumValue(minValue);
 206         __pDateTimeBarPresenter->SetMaximumValue(maxValue);
 207
 208         r = __pDateTimeBarPresenter->AddItems(displayValue);
 209         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 210
 211         return r;
 212 }
 213
 214 _DateTimeId
 215 _DateTimeBar::GetSelectedBoxId(void) const
 216 {
 217         return __selectedBoxId;
 218 }
 219
 220 void
 221 _DateTimeBar::SetSelectedBoxId(_DateTimeId boxId)
 222 {
 223         __selectedBoxId = boxId;
 224         return;
 225 }
 226
 227
 228 void
 229 _DateTimeBar::InitializeAccessibilityElement(void)
 230 {
 231         if (likely(!(_AccessibilityManager::IsActivated())))
 232         {
 233                 return;
 234         }
 235
 236         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 237
 238         if (pContainer)
 239         {
 240                 pContainer->Activate(true);
 241                 pContainer->AddListener(*this);
 242         }
 243
 244         return;
 245 }
 246
 247 int
 248 _DateTimeBar::GetItemCount(void) const
 249 {
 250         ClearLastResult();
 251
 252         return __pDateTimeBarPresenter->GetItemCount();
 253 }
 254
 255 result
 256 _DateTimeBar::AddActionEventListener(const _IActionEventListener& listener)
 257 {
 258         ClearLastResult();
 259
 260         result r = E_SUCCESS;
 261
 262         if (__pActionEvent == null)
 263         {
 264                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
 265                 SysTryReturn(NID_UI_CTRL, __pActionEvent != null, E_SYSTEM, E_SYSTEM,
 266                                         "[%s] Propagating.", GetErrorMessage(r));
 267         }
 268         r = __pActionEvent->AddListener(listener);
 269         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 270
 271         return r;
 272 }
 273
 274 result
 275 _DateTimeBar::RemoveActionEventListener(const _IActionEventListener& listener)
 276 {
 277         ClearLastResult();
 278
 279         result r = E_OBJ_NOT_FOUND;
 280
 281         if (__pActionEvent)
 282         {
 283                 r = __pActionEvent->RemoveListener(listener);
 284         }
 285
 286         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 287
 288         return r;
 289 }
 290
 291 result
 292 _DateTimeBar::AddDateTimeChangeEventListener(const _IDateTimeChangeEventListener& listener)
 293 {
 294         ClearLastResult();
 295
 296         return __pDateTimeChangeEvent->AddListener(listener);
 297 }
 298
 299 result
 300 _DateTimeBar::RemoveDateTimeChangeEventListener(const _IDateTimeChangeEventListener& listener)
 301 {
 302         ClearLastResult();
 303
 304         return __pDateTimeChangeEvent->RemoveListener(listener);
 305 }
 306
 307 result
 308 _DateTimeBar::FireDateTimeChangeEvent(_DateTimeChangeStatus status)
 309 {
 310         ClearLastResult();
 311
 312         _DateTimeChangeEventArg* pDateTimeEventArg = new (std::nothrow) _DateTimeChangeEventArg(status);
 313         SysTryReturn(NID_UI_CTRL, (pDateTimeEventArg != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 314                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 315
 316         __pDateTimeChangeEvent->Fire(*pDateTimeEventArg);
 317
 318         return E_SUCCESS;
 319 }
 320
 321 result
 322 _DateTimeBar::FireActionEvent(int actionId)
 323 {
 324         ClearLastResult();
 325
 326         if (__pActionEvent)
 327         {
 328                 Tizen::Base::Runtime::IEventArg* pEventArg = _ActionEvent::CreateActionEventArgN(actionId);
 329                 result r = GetLastResult();
 330                 SysTryReturn(NID_UI_CTRL, pEventArg, false, r, "[%s] Propagating.", GetErrorMessage(r));
 331
 332                 __pActionEvent->Fire(*pEventArg);
 333         }
 334
 335         return E_SUCCESS;
 336 }
 337
 338 result
 339 _DateTimeBar::CalculateArrowBounds(const Rectangle& bounds)
 340 {
 341         ClearLastResult();
 342
 343         Rectangle arrowBounds(0, 0, 0, 0);
 344
 345         arrowBounds = __pDateTimeBarPresenter->GetArrowBounds();
 346         arrowBounds.x = bounds.x + (bounds.width / 2) - (arrowBounds.width / 2);
 347         arrowBounds.x -= __pDateTimeBarPresenter->GetWindowBounds().x;
 348
 349         __pDateTimeBarPresenter->SetArrowBounds(arrowBounds);
 350
 351         return E_SUCCESS;
 352 }
 353
 354 bool
 355 _DateTimeBar::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 356 {
 357         ClearLastResult();
 358
 359         return __pDateTimeBarPresenter->OnTouchPressed(source, touchinfo);
 360 }
 361
 362 bool
 363 _DateTimeBar::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 364 {
 365         ClearLastResult();
 366
 367         return __pDateTimeBarPresenter->OnTouchReleased(source, touchinfo);
 368 }
 369
 370 bool
 371 _DateTimeBar::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 372 {
 373         ClearLastResult();
 374
 375         return __pDateTimeBarPresenter->OnTouchMoved(source, touchinfo);
 376 }
 377
 378 bool
 379 _DateTimeBar::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 380 {
 381         ClearLastResult();
 382
 383         return __pDateTimeBarPresenter->OnTouchCanceled(source, touchinfo);
 384 }
 385
 386 bool
 387 _DateTimeBar::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 388 {
 389         int xDistance = 0;
 390         int yDistance = 0;
 391         gesture.GetDistance(xDistance, yDistance);
 392         int duration = gesture.GetDuration();
 393
 394         return __pDateTimeBarPresenter->OnFlickGestureDetected(xDistance, yDistance, duration);
 395 }
 396
 397 bool
 398 _DateTimeBar::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 399 {
 400    return false;
 401 }
 402
 403 void
 404 _DateTimeBar::OnTouchMoveHandled(const Tizen::Ui::_Control& control)
 405 {
 406         ClearLastResult();
 407
 408         return __pDateTimeBarPresenter->OnTouchMoveHandled(control);
 409 }
 410
 411 result
 412 _DateTimeBar::OnAttachingToMainTree(const _Control* pParent)
 413 {
 414         if (GetOwner() == null)
 415         {
 416                 _Frame* pFrame = dynamic_cast<_Frame*>(_ControlManager::GetInstance()->GetCurrentFrame());
 417                 SysTryReturn(NID_UI_CTRL, pFrame != null, E_SYSTEM,
 418                                         E_SYSTEM, "[E_SYSTEM] This instance is not constructed.");
 419
 420                 _Form* pForm = pFrame->GetCurrentForm();
 421                 if (pForm != null)
 422                 {
 423                         SetOwner(pForm);
 424                 }
 425                 else
 426                 {
 427                         SetOwner(pFrame);
 428                 }
 429         }
 430
 431         return _Window::OnAttachingToMainTree(pParent);
 432 }
 433
 434 result
 435 _DateTimeBar::OnAttachedToMainTree(void)
 436 {
 437         _Window::OnAttachedToMainTree();
 438         return E_SUCCESS;
 439 }
 440
 441 result
 442 _DateTimeBar::OnDetachingFromMainTree(void)
 443 {
 444         return _Window::OnDetachingFromMainTree();
 445 }
 446
 447 void
 448 _DateTimeBar::OnActivated(void)
 449 {
 450         _Window::OnActivated();
 451
 452         int itemWidth = 0;
 453
 454         if (GetSelectedBoxId() == DATETIME_ID_MONTH)
 455         {
 456                 GET_SHAPE_CONFIG(DATETIMEBAR::MONTH_ITEM_WIDTH, _ControlManager::GetInstance()->GetOrientation(), itemWidth);
 457         }
 458         else if (GetSelectedBoxId() == DATETIME_ID_YEAR)
 459         {
 460                 GET_SHAPE_CONFIG(DATETIMEBAR::YEAR_ITEM_WIDTH, _ControlManager::GetInstance()->GetOrientation(), itemWidth);
 461         }
 462         else
 463         {
 464                 GET_SHAPE_CONFIG(DATETIMEBAR::DAY_ITEM_WIDTH, _ControlManager::GetInstance()->GetOrientation(), itemWidth);
 465         }
 466
 467         __pDateTimeBarPresenter->SetInitialAnimationValue(itemWidth);
 468
 469         __pDateTimeBarPresenter->StartAnimationEffect();
 470
 471         SetTouchCapture();
 472         return;
 473 }
 474
 475 void
 476 _DateTimeBar::OnDeactivated(void)
 477 {
 478         ReleaseTouchCapture();
 479         _Window::OnDeactivated();
 480         return;
 481 }
 482
 483 void
 484 _DateTimeBar::AddAccessibilityElement(const Rectangle& itemBounds, const Tizen::Base::String& itemText)
 485 {
 486         if (likely(!(_AccessibilityManager::IsActivated())))
 487         {
 488                 return;
 489         }
 490
 491         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 492         if (pContainer)
 493         {
 494                 _AccessibilityElement* pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
 495                 SysTryReturnVoidResult(NID_UI_CTRL, pAccessibilityElement != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 496
 497                 String labelText = itemText;
 498                 pAccessibilityElement->SetBounds(itemBounds);
 499                 pAccessibilityElement->SetLabel(labelText);
 500                 pAccessibilityElement->SetTrait(GetAccessibilityTraitValue());
 501                 pContainer->AddElement(*pAccessibilityElement);
 502                 __accessibilityElements.Add(pAccessibilityElement);
 503         }
 504
 505         return;
 506 }
 507
 508 void
 509 _DateTimeBar::RemoveAllAccessibilityElement(void)
 510 {
 511         if (likely(!(_AccessibilityManager::IsActivated())))
 512         {
 513                 return;
 514         }
 515
 516         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 517
 518         if (pContainer == null)
 519         {
 520                 return;
 521         }
 522
 523         _AccessibilityElement* pAccessibilityElement = null;
 524
 525         while (__accessibilityElements.GetCount() > 0)
 526         {
 527                 if ((__accessibilityElements.GetAt(0, pAccessibilityElement)) == E_SUCCESS)
 528                 {
 529                         __accessibilityElements.RemoveAt(0);
 530                         pContainer->RemoveElement(*pAccessibilityElement);
 531                 }
 532                 else
 533                 {
 534                         __accessibilityElements.RemoveAt(0);
 535                 }
 536         }
 537
 538         return;
 539 }
 540
 541 AccessibilityTraits
 542 _DateTimeBar::GetAccessibilityTraitValue()
 543 {
 544         AccessibilityTraits traitsValue = ACCESSIBILITY_TRAITS_NONE;
 545
 546         if (GetSelectedBoxId() == DATETIME_ID_DAY)
 547         {
 548                 traitsValue = ACCESSIBILITY_TRAITS_DAY;
 549         }
 550         else if (GetSelectedBoxId() == DATETIME_ID_MONTH)
 551         {
 552                 traitsValue = ACCESSIBILITY_TRAITS_MONTH;
 553         }
 554         else if (GetSelectedBoxId() == DATETIME_ID_YEAR)
 555         {
 556                 traitsValue = ACCESSIBILITY_TRAITS_YEAR;
 557         }
 558         else if (GetSelectedBoxId() == DATETIME_ID_HOUR)
 559         {
 560                 traitsValue = ACCESSIBILITY_TRAITS_HOUR;
 561         }
 562         else if (GetSelectedBoxId() == DATETIME_ID_MINUTE)
 563         {
 564                 traitsValue = ACCESSIBILITY_TRAITS_MINUTE;
 565         }
 566
 567         return traitsValue;
 568 }
 569
 570 String
 571 _DateTimeBar::GetMonthValue(int month) const
 572 {
 573         String monthValue;
 574
 575         switch (month)
 576         {
 577         case 1:
 578                 monthValue = L"January";
 579                 break;
 580         case 2:
 581                 monthValue = L"February";
 582                 break;
 583         case 3:
 584                 monthValue = L"March";
 585                 break;
 586         case 4:
 587                 monthValue = L"April";
 588                 break;
 589         case 5:
 590                 monthValue = L"May";
 591                 break;
 592         case 6:
 593                 monthValue = L"June";
 594                 break;
 595         case 7:
 596                 monthValue = L"July";
 597                 break;
 598         case 8:
 599                 monthValue = L"August";
 600                 break;
 601         case 9:
 602                 monthValue = L"September";
 603                 break;
 604         case 10:
 605                 monthValue = L"October";
 606                 break;
 607         case 11:
 608                 monthValue = L"November";
 609                 break;
 610         case 12:
 611                 monthValue = L"December";
 612                 break;
 613         default:
 614                 monthValue = L"";
 615         }
 616
 617         return monthValue;
 618 }
 619
 620 void
 621 _DateTimeBar::SetFont(Font& pFont)
 622 {
 623         __pDateTimeBarPresenter->SetFont(pFont);
 624
 625         return;
 626 }
 627
 628 void
 629 _DateTimeBar::SetParentWindowBounds(Rectangle& parentWindowBounds)
 630 {
 631         __parentWindowBounds = parentWindowBounds;
 632         return;
 633 }
 634
 635 Rectangle
 636 _DateTimeBar::GetParentWindowBounds() const
 637 {
 638         return __parentWindowBounds;
 639 }
 640
 641 bool
 642 _DateTimeBar::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 643 {
 644         return __pDateTimeBarPresenter->OnAccessibilityFocusMovedNext(control, element);
 645 }
 646
 647 bool
 648 _DateTimeBar::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 649 {
 650         return __pDateTimeBarPresenter->OnAccessibilityFocusMovedPrevious(control, element);
 651 }
 652
 653 bool
 654 _DateTimeBar::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 655 {
 656         return false;
 657 }
 658
 659 bool
 660 _DateTimeBar::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 661 {
 662         return false;
 663 }
 664
 665 bool
 666 _DateTimeBar::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 667 {
 668         return false;
 669 }
 670
 671 bool
 672 _DateTimeBar::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 673 {
 674         return false;
 675 }
 676
 677 bool
 678 _DateTimeBar::OnAccessibilityValueIncreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&)
 679 {
 680         return false;
 681 }
 682
 683 bool
 684 _DateTimeBar::OnAccessibilityValueDecreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&)
 685 {
 686         return false;
 687 }
 688
 689 }}} // Tizen::Ui::Controls