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