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